wadackel/dotfiles/simplify-review
Claude Code and agent skill by wadackel/dotfiles
- community
Checking that the SKILL.md file is still in the repository.
Reviews plans and code for over-engineering, then proposes simplifications. Spawns a fresh subagent (plan-simplifier or code-simplifier) with no prior context to objectively detect unnecessary complexity — abstractions without callers, speculative features, excessive error handling, premature optimization. Use when asked to 'simplify', 'シンプルにして', 'simplify review', '過剰設計をレビュー', '簡素化', or 'YAGNI check'.
Install
npx vskill@latest install wadackel/dotfiles/simplify-reviewSKILL.md
Simplify Review
Detects over-engineering in plans and code by spawning a fresh subagent (plan-simplifier / code-simplifier) that reviews from a clean perspective. The reviewer has no knowledge of the design journey — only the artifact and its context — so it naturally spots complexity that feels justified to the author but isn't justified by the requirements.
This skill is the entry point for an independent simplification review. /impl reviews simplification in the main session, /do picks the smallest option there and has its reviewer, when it dispatches one, flag what the intent did not ask for; neither dispatches these subagents on its own, so a plan or diff gets a fresh-context simplification pass only through this skill.
Why This Matters
Iterative plan deepening improves quality, but each round can also add complexity: extra error handling "just in case", abstractions for hypothetical future use, defensive patterns against scenarios that can't happen. Humans catch this through experience ("this feels over-built"). This skill codifies that instinct.
Quick Start
When to Use
| Context | Trigger | |
|---|---|---|
| User says "simplify", "YAGNI check", "過剰設計をレビュー" | Manual | |
| Re-running simplify on an already-iterated plan / diff | Manual | |
Independent review of a plan or diff before /impl's review, or before a /do change ships | Manual | |
| User review feedback says "too complex" | Reactive |
Manual Workflow
On /simplify-review invocation, parse $ARGUMENTS:
plan→ dispatchplan-simplifierwith the current plan file, the original user request, and a summary of the project's conventions from its CLAUDE.md / AGENTS.md.code→ dispatchcode-simplifierwith the changed files,git diff(orgit diff <baseline_sha>..HEAD), and the project CLAUDE.md path.autoor empty — detect: plan mode active →plan; otherwise uncommitted changes or a recent task completion →code; both applicable → runplanfirst, thencode.
Both subagents return categorized proposals (per-proposal: confidence, rationale, before / after, risk) plus a verdict of SIMPLIFY or MINIMAL. Triage them with the protocol below, apply approved changes, and present a results summary.
Triage Protocol
Confidence-Based Triage
| Confidence | Criteria | Action | |
|---|---|---|---|
| HIGH | Objective, mechanical improvement (dead code removal, redundant null check, unused import) | Main session may auto-apply (see Auto-Apply Rules) | |
| MEDIUM | Clear improvement but involves judgment (simpler algorithm, flatten abstraction) | Present to user for approval | |
| LOW | Trade-off involved (fewer abstractions vs. extensibility, less error handling vs. robustness) | Present to user, recommend but don't push |
Auto-Apply Rules
The main session auto-applies HIGH-confidence proposals only when all of these hold:
- The change is purely subtractive (removes code/steps) or a direct substitution
- No behavioral change — functionality is preserved
- No scope reduction — the set of supported actions/endpoints/contexts is unchanged
- No removal of correctness mechanisms — items the plan explicitly identifies as needed for correctness (guards, synchronization, validation) require code-level verification before removal and cannot be auto-applied
- The proposal follows the simplifier's YAGNI / KISS / DRY lens and does not contradict the project's conventions
- The change does not affect public APIs or user-facing interfaces
When auto-applying, log what was applied and why; surface MEDIUM / LOW proposals to the user before changes. After applying, run relevant tests / static checks to confirm no behavioral regression; revert and report on regression.
Integration Points
/impl's review is complementary: it audits evidence and checks spec compliance + code quality + domain + security at the final gate.simplify-reviewtargets unnecessary complexity specifically. Run order when both apply: implementation →simplify-review(code-simplifier) →/impl's review.
Design Decisions
Why a fresh subagent (not inline review): The main session has followed the entire design journey. It knows why each decision was made, which makes it blind to unnecessary complexity — every piece feels justified in context. A fresh subagent sees only the artifact and naturally asks "is this needed?" without the sunk-cost bias.
Why dedicated `plan-simplifier` / `code-simplifier` subagents (not a generic `Plan` or `code-reviewer` agent): The Skill tool loads a skill's text into context and spawns nothing, so a prompt template kept in a skill cannot run in parallel with other Agent calls. First-class agent definitions spawn directly through the Agent tool and run in parallel.
Why two separate agents (plan vs code): Input shape (plan text vs git diff) and evaluation focus (structure vs implementation) differ enough that merging them into one agent with a mode switch would bloat the system prompt without benefit.
Why confidence-based triage instead of binary PASS/FAIL: Simplification is inherently subjective. Some proposals are obvious wins (dead code), others are judgment calls. Confidence-based triage lets the main session auto-apply safe changes while escalating trade-offs to the user.
Why auto-apply HIGH confidence: Requiring user approval for every dead code removal creates noise. The guardrails (subtractive only, no behavioral change, consistent with the project's conventions) ensure auto-applied changes are safe.
Why this skill has no step-by-step workflow: the review instructions live in the plan-simplifier and code-simplifier agent definitions. This skill holds only what the main session needs around a manual dispatch: the inputs to pass and the triage / auto-apply protocol for what comes back.
Security
- Security scanPassed, 90 of 100Pattern checks on the skill's files.
- Model reviewPassed
Quality evaluation
- Task evaluationNot runNo evaluation yet. Run one in Skill Studio.
Source
- SKILL.md in the repositoryCheckinghome/programs/agents/skills/simplify-review/SKILL.md
Popularity
- 7-day trend score
- 0
Not refreshed yet.
Works with
Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.
- Claude Code
- Cursor
- GitHub Copilot
- Windsurf
- Codex
- Gemini CLI
- Cline
- Amp
- Roo Code
- Goose
- Continue
- Kilo Code
- Junie
- Trae
- OpenHands
- Qwen Code
- AI Agent
- Tabnine Chat
- Sourcegraph Cody
- Amazon Q
- Firebase Genkit
- Sweep
- Devin
- Phind
- Mentat
- Claude Desktop
- Aider
- GPT Pilot
- Plandex
- bolt.new
- v0
- Replit Agent
- Anse
- TypingMind
- BetterChatGPT
- LibreChat
- Warp AI
- Pieces
- Fig AI
Embed badge
[](https://verified-skill.com/skills/wadackel/dotfiles/simplify-review)