Skip to main content
command CX Codex

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

Install into Claude Code · Manually: put the files in place All methods and platforms ↓
.claude/commands/code-simplifier.md
Open on GitHub

What 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-simplifier and 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.md

Call it with /code-simplifier. For all projects use ~/.claude/commands/

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

Similar slash commands

All slash commands for Code review and refactoring →

From the same set46

The whole set →
review Sets Claude Code to run strict engineering reviews, triaging issues from critical security flaws to minor stylistic fixes. CX Codex +1 ★ 1,424repo stars lint-check lint-check runs the linters your project already configures, sorts findings by severity and can auto-fix style. Useful right before a commit instead of waiting for CI. CX Codex +1 ★ 1,424repo stars run-tests run-tests runs the project's tests in tiers: the ones your changes touch first, then the whole unit suite, then integration. CX Codex +1 ★ 1,424repo stars parallel-review parallel-review runs code review across multiple directories or files simultaneously, one subagent per target. CX Codex +1 ★ 1,424repo stars security-scan security-scan is a command for Claude Code that checks a repository for hardcoded secrets, vulnerable dependencies, injection, XSS and weak config before a commit or PR. CX Codex +1 ★ 1,424repo stars verify-changes verify-changes executes adversarial multi-subagent verification across recent code diffs to weed out bugs and false alarms. CX Codex +1 ★ 1,424repo stars save-session-learnings The save-session-learnings command for Claude Code saves useful findings from a coding session to CLAUDE.md and AGENTS.md after debugging or a substantial task. CX Codex +1 ★ 1,424repo stars analyzing-projects analyzing-projects walks through an unfamiliar codebase step by step: stack, structure, patterns, dev commands — useful when onboarding onto a project. CX Codex +1 ★ 1,424repo stars

Project sponsors

Companies that keep this analytics open