code-simplifier — Claude Code command: simplify and install
The code-simplifier command reviews recent changes and proposes cleaner code without changing behavior. Use it after implementing a feature or refactoring.
MIT ★ 1,424 updated 2026-10-06
.claude/commands/code-simplifier.mdWhat code-simplifier does
code-simplifier inspects the latest work with git diff HEAD~1 --name-only, git log -1 --stat, and git diff HEAD~1. It looks for repeated logic, dead code, excessive abstractions, tangled conditionals, and functions with too many responsibilities. Each finding includes its location, a current and simpler version, plus the expected benefit and risk.
The command waits for approval before editing. Approved changes are applied one at a time, with tests run after each edit, while public APIs remain intact. It also suggests commits using refactor: simplify [description]. The command is invoked from the plugin with /project-starter:code-simplifier.
What it helps with
- inspect the latest diff after implementing a feature
- remove duplicated logic and one-off wrappers
- find unused code, imports, and dependencies
- flatten nested conditionals and split long functions
- verify each refactoring step with tests
Example prompts for the agent
- Run
/project-starter:code-simplifierand review the latest changes. - Inspect the recent diff for dead code, duplicate logic, and unnecessary abstractions without changing behavior.
- Show a current and simplified version for each finding, then apply the approved changes one at a time.
How to install code-simplifier
Manually: put the files in place
.claude/commands/code-simplifier.mdCall it with /code-simplifier. For all projects use ~/.claude/commands/
Manually: put the files in place
~/.codex/prompts/code-simplifier.mdCall it with /prompts:code-simplifier. Codex marks this format deprecated in favour of skills
Manually: put the files in place
.github/prompts/code-simplifier.prompt.mdManually: put the files in place
.gemini/commands/code-simplifier.tomlGemini stores commands as TOML: the prompt text goes into the prompt field
Questions about code-simplifier
How do I install code-simplifier in Claude Code?
Place the command file at .claude/commands/code-simplifier.md. Then invoke it with /project-starter:code-simplifier.
What does code-simplifier do?
It reviews recent changes for duplicated logic, dead code, extra abstractions, and complex conditions. The command proposes structural refactors while preserving behavior and public APIs.
Does code-simplifier edit code without approval?
No. It presents proposed simplifications first, then applies approved changes individually and runs tests after each edit.
Source text
code-simplifier.md · MIT
---
description: Simplifies code after implementation. Reviews recent changes and suggests/applies simplifications while preserving behavior.
---
# Code Simplifier
Simplify code after implementation. Find ways to make code cleaner and simpler without changing behavior.
## Philosophy
- Simpler is better
- Less code = fewer bugs
- Clarity over cleverness
- Don't change behavior, only structure
- Delete code when possible
## Phase 1: Identify Recent Changes
```bash
git diff HEAD~1 --name-only
git log -1 --stat
git diff HEAD~1
```
## Phase 2: Analyze for Simplification
Look for these patterns:
### 1. Duplicate Code
- Repeated logic that can be extracted
- Similar functions that can be merged
- Copy-pasted code with minor variations
### 2. Over-Engineering
- Abstractions used only once
- Unnecessary wrapper functions
- Over-parameterized functions (too many options)
- Premature generalization
### 3. Dead Code
- Unused variables
- Unreachable branches
- Commented-out code
- Unused imports/dependencies
### 4. Complex Conditionals
- Nested if-else chains (flatten with early returns)
- Complex boolean expressions (extract to named variables)
- Guard clauses that can be simplified
### 5. Long Functions
- Functions > 20 lines (consider splitting)
- Multiple responsibilities (single responsibility)
- Too many parameters (use objects)
### 6. Unnecessary Complexity
- Try-catch around code that can't fail
- Null checks on values that can't be null
- Defensive code for impossible cases
## Phase 3: Propose Simplifications
For each finding, present:
````
### Simplification: [Short description]
**Location**: `file:line`
**Type**: [Duplicate/Over-engineering/Dead code/etc.]
**Current** (X lines):
```[lang]
[code block]
```
**Simplified** (Y lines):
```[lang]
[code block]
```
**Benefit**: [Why this is better]
**Risk**: Low - behavior unchanged
````
## Phase 4: Apply Simplifications
After user approval:
1. Make one change at a time
2. Run tests after each change
3. Commit with clear message: `refactor: simplify [description]`
4. Move to next simplification
## Output Format
```
## Simplification Report
### Changes Analyzed
- Files: [count]
- Lines added: [count]
- Lines removed: [count]
### Simplification Opportunities
[List each opportunity with current/simplified code]
### Summary
- Simplifications found: X
- Estimated lines reducible: Y
- Complexity reduction: [High/Medium/Low]
### Recommended Actions
1. [ ] Apply simplification #1 (highest impact)
2. [ ] Apply simplification #2
...
### Tests to Run After
- [List of test commands to verify no behavior change]
```
## Safety Rules
1. **Never change behavior** - only structure
2. **Run tests after every change** - verify nothing broke
3. **Keep changes atomic** - one simplification per commit
4. **Document what was simplified** - clear commit messages
5. **Preserve public APIs** - internal refactoring only
## Usage
This command ships with the project-starter plugin. Invoke with: `/project-starter:code-simplifier`
© CloudAI-X · MIT · CloudAI-X/claude-workflow-v2