Code Simplification Skill
Multi-agent code analysis and simplification workflow.
Execution Flow
┌─────────────────────────────────────────────────────────┐
│ 1. Determine Scope (git diff or user input) │
├─────────────────────────────────────────────────────────┤
│ 2. Phase 1: 4 Analysis Agents (Parallel) │
│ ┌─────────────────┬─────────────────┐ │
│ │ complexity- │ pattern- │ │
│ │ analyzer │ checker │ │
│ ├─────────────────┼─────────────────┤ │
│ │ naming- │ readability- │ │
│ │ reviewer │ analyzer │ │
│ └─────────────────┴─────────────────┘ │
├─────────────────────────────────────────────────────────┤
│ 3. Consolidate Issues │
├─────────────────────────────────────────────────────────┤
│ 4. Phase 2: Issue Simplifiers (Parallel) │
│ ┌────────┬────────┬────────┬────────┐ │
│ │ issue1 │ issue2 │ issue3 │ ... │ │
│ └────────┴────────┴────────┴────────┘ │
├─────────────────────────────────────────────────────────┤
│ 5. Present Changes & AskUserQuestion │
├─────────────────────────────────────────────────────────┤
│ 6. Apply Selected Changes │
└─────────────────────────────────────────────────────────┘Step 1: Determine Scope
With Arguments
Use provided file/directory path as scope.
Without Arguments (Recent Changes)
git diff --name-only HEAD~3 2>/dev/null | grep -E '\.(ts|tsx|js|jsx|py|go|rs|java)$'If no git changes, ask user for scope.
Step 2: Phase 1 - Analysis Agents (Parallel)
Execute 4 agents in parallel (single message with 4 Task calls).
Scope Context (Provide to all agents)
Scope:
- Files: [List of files to analyze]
- Recent changes: [git diff summary if available]Parallel Execution
Task(subagent_type="simplify:complexity-analyzer", ...)
Task(subagent_type="simplify:pattern-checker", ...)
Task(subagent_type="simplify:naming-reviewer", ...)
Task(subagent_type="simplify:readability-analyzer", ...)| Agent | Role | Output |
|---|---|---|
| complexity-analyzer | Nested ternary, deep nesting, over-abstraction | Issue list with locations |
| pattern-checker | Project standards violation, inconsistency | Issue list with locations |
| naming-reviewer | Variable/function naming improvements | Issue list with suggestions |
| readability-analyzer | Readability issues, unnecessary comments | Issue list with suggestions |
Step 3: Consolidate Issues
Merge results from all 4 agents into a unified issue list:
## Issues Found
### Issue 1: [Title]
- **File:** path/to/file.ts:42
- **Type:** complexity | pattern | naming | readability
- **Description:** [What's wrong]
- **Suggestion:** [How to fix]
### Issue 2: [Title]
...If no issues found, report "No improvements needed" and end.
Step 4: Phase 2 - Issue Simplifiers (Parallel)
For each issue, run an issue-simplifier agent in parallel:
Task(subagent_type="simplify:issue-simplifier", prompt="""
Issue: [Issue title]
File: [file path]
Location: [line numbers]
Type: [issue type]
Description: [description]
Suggestion: [suggestion]
Read the file and provide the exact code change needed.
Output format:
- Original code block
- Simplified code block
- Brief explanation
""")IMPORTANT: Run ALL issue-simplifier agents in a single message with multiple Task calls.
Step 5: Present Changes
Compile all proposed changes:
## Proposed Simplifications
### 1. [File:Line] - [Issue Type]
**Original:**[original code]
**Simplified:**
[simplified code]
**Reason:** [explanation]
---
### 2. [File:Line] - [Issue Type]
...
Step 6: Action Selection
AskUserQuestion(questions=[{"question": "Which simplifications would you like to apply?", "header": "Apply", "multiSelect": true, "options": [{"label": "Apply all (Recommended)", "description": "Apply all proposed changes"}, {"label": "Select individually", "description": "Choose specific changes"}, {"label": "Skip", "description": "Don't apply any changes"}]}])
If "Select individually", present each change for approval.
Step 7: Apply Selected Changes
Use Edit tool to apply approved changes.
Principles
- Clarity over Brevity: Explicit, readable code over compact one-liners
- No Nested Ternaries: Use switch/if-else for multiple conditions
- Reduce Complexity: Eliminate unnecessary nesting and redundant abstractions
- Preserve Functionality: Never change what code does, only how it's written
Example Improvements
- Nested ternary operators → clear if/else chains
- Deep nesting → early returns or extracted functions
- Redundant abstractions → direct implementations
- Unclear names → descriptive identifiers