Skill

simplify-implementation

Analyzes existing code for complexity sources like nesting and duplication, then proposes simplifications via extraction, flattening, decoupling, and removal. Use for refactoring, readability improvements, cleanup, and technical debt reduction.

code-quality

npx claudepluginhub codeaholicguy/ai-devkit

Tool Access

This skill uses the workspace's default tool permissions.

Preview

Reduce complexity with an analysis-first approach before changing code.

Supporting Assets

agents/openai.yamlreferences/readability-guide.md

SKILL.md

Similar Skills

code-simplifier

Refines existing code for clarity, readability, and maintainability without changing behavior, interfaces, or outputs. Use for simplify, clean up, refactor for readability requests.

amplify

code-simplification

30.8k

Simplifies code for clarity while preserving exact behavior. Use for refactoring complex but functional code, code reviews, reducing unnecessary complexity, and improving readability/maintainability.

agent-skills

code-simplification

Reduces nesting, extracts descriptive names, eliminates redundancy in code without changing behavior. Triggers on 'simplify', 'refactor for clarity', readability issues, or code review complexity flags.

5 tools

nexus-agents

Stats

Stars1178

Forks190

Last CommitApr 3, 2026

Actions

View Source View Plugin View on GitHub View README

Help us improve

Share bugs, ideas, or general feedback.

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

Gather Context

Confirm targets, pain points, and constraints (compatibility, API stability, deadlines).
Search for past simplification decisions or known constraints: npx ai-devkit@latest memory search --query "<target area>" --tags "simplify"

Analyze Complexity

Identify sources (nesting, duplication, coupling, over-engineering, magic values).
Assess impact (LOC, dependencies, cognitive load, scalability blockers).

Apply Readability Principles

Apply the readability guide and its "Reading Test".

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.

Prioritize and Plan

Rank by impact/risk. Present plan with before/after snippets. Request approval.

Red Flags and Rationalizations

Rationalization	Why It's Wrong	Do Instead
"While I'm here, let me refactor this too"	Scope creep breaks things	Only simplify what was requested
"This abstraction will help later"	Predicted reuse rarely materializes	Remove it unless used twice today
"Shorter is simpler"	Brevity can hide complexity	Optimize for readability, not line count

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