feat(skills): add simplify-implementation

Author: codeaholicguy

skills/simplify-implementation/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: simplify-implementation
+description: Analyze and simplify existing implementations to reduce complexity, improve maintainability, and enhance scalability. Use when users ask to simplify code, reduce complexity, refactor for readability, clean up implementations, improve maintainability, reduce technical debt, or make code easier to understand.
+---
+
+# Simplify Implementation Assistant
+
+Reduce complexity with an analysis-first approach before changing code.
+
+## Hard Rules
+- Do not modify code until the user approves a simplification plan.
+- Readability over brevity. Some duplication beats the wrong abstraction.
+
+## Workflow
+
+1. Gather Context
+- Confirm targets, pain points, and constraints (compatibility, API stability, deadlines).
+
+2. Analyze Complexity
+- Identify sources (nesting, duplication, coupling, over-engineering, magic values).
+- Assess impact (LOC, dependencies, cognitive load, scalability blockers).
+
+3. Apply Readability Principles
+- Apply the [readability guide](references/readability-guide.md) and its "Reading Test".
+
+4. Propose Simplifications
+For each issue, apply a pattern:
+- **Extract**: Long functions → smaller, focused functions.
+- **Consolidate**: Duplicate code → shared utilities.
+- **Flatten**: Deep nesting → early returns, guard clauses.
+- **Decouple**: Tight coupling → dependency injection, interfaces.
+- **Remove**: Dead code, unused features, excessive abstractions.
+- **Replace**: Complex logic → built-in language/library features.
+- **Defer**: Premature optimization → measure-first approach.
+
+5. Prioritize and Plan
+- Rank by impact/risk. Present plan with before/after snippets. Request approval.
+
+## Validation
+- Verify no regressions, add tests for new helpers, update docs if interfaces changed.
+
+## Output Template
+- Target and Context
+- Complexity Analysis
+- Simplification Proposals (prioritized)
+- Recommended Order and Plan
+- Scalability Recommendations
+- Validation Checklist

skills/simplify-implementation/references/readability-guide.md

@@ -0,0 +1,30 @@
+# Readability Guide
+
+**Good code reads like a good book — naturally, from left to right, top to bottom.**
+
+## DO
+- **Linear flow**: Read top-to-bottom without jumping around.
+- **Explicit over implicit**: Clear code over clever shortcuts.
+- **Meaningful names**: Purpose obvious without comments.
+- **Consistent patterns**: Same patterns throughout the codebase.
+- **Single abstraction level**: One level of abstraction per function.
+- **Logical grouping**: Blank lines to separate logical blocks.
+
+## AVOID: Over-Optimization for Brevity
+
+These patterns harm readability — prefer the alternative:
+- **Nested ternaries** (`a ? b ? c : d : e`) → explicit if/else.
+- **Chained one-liners** (`.map().filter().reduce().flat()`) → named intermediate steps.
+- **Clever bitwise tricks** (`n & 1` for odd check) → readable arithmetic.
+- **Short variable names** (`x`, `y`, `z`) → descriptive names (`users`, `activeUsers`).
+- **Implicit returns everywhere** → explicit returns for complex logic.
+- **Magic one-liners** (regex/reduce that "do everything") → documented steps.
+- **Premature DRY** (abstraction to avoid 2-3 lines of duplication) → some duplication is clearer.
+
+## The "Reading Test"
+
+For each simplification, all four must be "yes":
+1. Can a new team member understand this in under 30 seconds?
+2. Does the code flow naturally without jumping to other files?
+3. Are there any "wait, what does this do?" moments?
+4. Would this code still be clear 6 months from now?