skill updates

commands/simplify.md

@@ -0,0 +1,84 @@
+---
+description: Simplify overly complex code while preserving full functionality
+allowed-tools: Read, Edit, Bash(git diff:*), Bash(git status:*), Grep, Glob
+argument-hint: [staged|unstaged|both]
+---
+
+# Simplify Implementation
+
+You are reviewing code you just wrote to simplify it. Claude has a tendency to over-engineer. Your job is to ruthlessly simplify while preserving full functionality.
+
+## Context
+
+Current git status: !`git status --short`
+
+### Changes to Review
+
+Based on the argument provided ($ARGUMENTS), review the appropriate diff:
+
+- **staged** (or no argument): Review staged changes only
+- **unstaged**: Review unstaged changes only
+- **both**: Review all changes (staged and unstaged)
+
+Staged changes: !`git diff --cached`
+Unstaged changes: !`git diff`
+
+## Simplification Principles
+
+### Remove Over-Engineering
+
+1. **Delete unnecessary abstractions**: If a function is called once, inline it
+2. **Remove premature generalization**: Delete parameters, options, or config that aren't used
+3. **Flatten unnecessary nesting**: Reduce indirection levels
+4. **Kill dead code paths**: Remove conditionals that can't trigger
+5. **Simplify error handling**: Don't catch errors you can't meaningfully handle
+6. **Remove defensive coding against impossible states**: Trust internal code
+
+### Prefer Direct Solutions
+
+1. **Three lines > one abstraction**: Repeated simple code beats a premature helper
+2. **Explicit > clever**: Readable beats compact
+3. **Flat > nested**: Early returns, guard clauses
+4. **Concrete > generic**: Solve the actual problem, not hypothetical ones
+5. **Standard library > custom implementation**: Use built-ins when available
+
+### Preserve
+
+1. **All functionality**: The feature must work exactly as before
+2. **Public interfaces**: Don't change signatures that external code depends on
+3. **Test coverage**: Existing tests must still pass
+4. **Actual error handling**: Keep meaningful error cases
+
+## Your Task
+
+1. **Analyze the diff**: Identify over-engineered patterns
+2. **List simplifications**: For each issue, explain what's complex and how to simplify
+3. **Apply changes**: Edit the files to simplify
+4. **Verify**: Ensure functionality is preserved
+
+## Output Format
+
+For each simplification:
+```
+FILE: path/to/file.ts
+
+ISSUE: [What's over-engineered]
+BEFORE: [Brief description or code snippet]
+AFTER: [Brief description or code snippet]
+WHY: [Why this is simpler without losing functionality]
+```
+
+Then apply the edits.
+
+## Red Flags to Watch For
+
+- Functions with > 3 parameters (probably doing too much)
+- Deeply nested callbacks or conditionals (flatten them)
+- Abstract base classes with one implementation (delete the abstraction)
+- Config objects for things that could be hardcoded
+- Wrapper functions that just call another function
+- Comments explaining what code does (code should be self-explanatory)
+- Type definitions that duplicate structure (use inference)
+- Utility functions used once (inline them)
+- Try/catch that just re-throws or logs (let it bubble)
+- Feature flags for features that are always on