claude-plugins/plugins/workflow/commands/simplify.md

description: Simplify code after implementation - reduce complexity without changing behavior argument-hint: [file-or-pattern] - Optional file path or glob pattern to focus on

Code Simplifier

Pre-computed Context

Recently Modified Files: !git diff --name-only HEAD~3 2>/dev/null | grep -E '\.(ts|tsx|js|jsx|py|go|rs)$' | head -10

Staged Files: !git diff --cached --name-only | grep -E '\.(ts|tsx|js|jsx|py|go|rs)$' | head -10

Changed Lines (recent): !git diff --stat HEAD~3 2>/dev/null | tail -5

---

Instructions

You are simplifying recently changed code. The goal is to reduce complexity while maintaining identical behavior.

Target Files

If argument provided, focus on that file/pattern. Otherwise, use the recently modified files shown above.

Simplification Patterns

Look for these opportunities:

1. Conditional Simplification

// Before
if (condition) {
  return true;
} else {
  return false;
}

// After
return condition;

2. Guard Clauses

// Before
function process(data) {
  if (data) {
    if (data.valid) {
      // long logic
    }
  }
}

// After
function process(data) {
  if (!data || !data.valid) return;
  // long logic
}

3. Optional Chaining

// Before
const name = user && user.profile && user.profile.name;

// After
const name = user?.profile?.name;

4. Nullish Coalescing

// Before
const value = data !== null && data !== undefined ? data : defaultValue;

// After
const value = data ?? defaultValue;

5. Array Methods

// Before
let result = [];
for (let i = 0; i < items.length; i++) {
  if (items[i].active) {
    result.push(items[i].name);
  }
}

// After
const result = items.filter(i => i.active).map(i => i.name);

6. Destructuring

// Before
const name = props.name;
const age = props.age;
const email = props.email;

// After
const { name, age, email } = props;

Rules

1. Do NOT change APIs - function signatures, exports, and interfaces stay the same
2. Do NOT change behavior - output must be identical for all inputs
3. Keep it readable - sometimes verbose is clearer; don't over-optimize
4. Test after changes - verify nothing broke

Process

1. Read target files
2. Identify simplification opportunities
3. Apply changes using Edit tool
4. Report summary: lines before vs after

Report Format

## Simplification Report

### File: <path>
- Lines: 150 → 120 (20% reduction)
- Changes:
  - Converted 3 if/else to ternary
  - Applied guard clauses in 2 functions
  - Replaced loop with array methods

### Total
- Files simplified: N
- Lines removed: N

---

Subagent Mode

For larger codebases, spawn a subagent:

Use Task tool with subagent_type="general-purpose" to analyze and simplify
multiple files in parallel.