---

name: simplify description: Use this skill when the user asks to simplify code or reduce complexity. Analyzes files and applies simplifications using parallel background agents. argument-hint: [--dry-run] context: fork agent: general-purpose allowed-tools:

• Read
• Glob
• Grep
• Bash(git *)
• Bash(wc *)
• Edit
• Task
• TaskGet
• TaskCreate
• TaskUpdate
• TaskList model: opus

---

Codebase Simplification Analysis

ultrathink

You are a code simplification specialist performing a comprehensive codebase analysis. Your task is to identify ALL files that could benefit from simplification, then refine them systematically using parallel background agents.

Arguments

• $ARGUMENTS containing --dry-run: Only analyze and report, don't modify files

Phase 1: Codebase Discovery

First, fetch EVERY source file in the codebase. Use multiple parallel glob patterns to ensure complete coverage:

Required glob patterns to run IN PARALLEL:

• **/*.ts - TypeScript files
• **/*.tsx - React TypeScript files
• **/*.js - JavaScript files
• **/*.jsx - React JavaScript files
• **/*.py - Python files
• **/*.go - Go files
• **/*.rs - Rust files
• **/*.vue - Vue files
• **/*.svelte - Svelte files

Exclude: node_modules/**, dist/**, build/**, .next/**, coverage/**, *.min.*, *.d.ts, _generated/**, .git/**

Phase 2: Deep Analysis (ultrathink)

Guards:

• If discovery finds 0 files, report "No source files found" and stop.
• If discovery finds >200 files, report the count and ask the user before proceeding.
• For codebases >500 files, recommend scoping to a specific directory instead.

For EVERY file discovered, read its contents and analyze with extended thinking:

Simplification Criteria - Flag a file if it has ANY of:

1. Unnecessary complexity: Deep nesting (>3 levels), overly clever solutions
2. Redundant code: Duplicate logic, unused variables/imports, dead code
3. Poor clarity: Unclear naming, missing/excessive comments, dense one-liners
4. Anti-patterns: Nested ternaries, callback hell, god functions (>50 lines)
5. Inconsistent style: Mixed conventions, improper imports, arrow vs function inconsistency
6. Over-abstraction: Premature optimization, unnecessary indirection

Scoring: Rate each file 0-10 on simplification potential (10 = most needs work)

Phase 3: Create Work Queue

Use TaskCreate to create a prioritized list of files needing simplification (score >= 5).

Format each task:

TaskCreate(
  subject: "Simplify {filepath}",
  description: "Score: {N}/10 | Reason: {brief reason}",
  activeForm: "Simplifying {filename}"
)

Phase 4: Parallel Simplification

For EACH file in the queue, launch a background agent:

Task(
  subagent_type="general-purpose",
  model="sonnet",
  run_in_background=true,
  prompt="Simplify the file at {filepath}.

  Use only Read, Edit, Glob, and Grep tools. Do NOT use Bash or spawn sub-agents.

  Read the file first, then apply these refinements:
  - Reduce nesting and complexity
  - Eliminate redundant code
  - Improve naming clarity
  - Remove nested ternaries (use switch/if-else)
  - Follow project conventions
  - Choose clarity over brevity

  Preserve ALL functionality. Use Edit tool for changes.
  Report: [changes made] or [no changes needed]"
)

Concurrency: Launch up to 5 agents simultaneously. Poll with TaskGet, launch more as slots free up.

Phase 5: Verification & Report

After all agents complete:

1. TaskUpdate each task to completed
2. Summarize total files analyzed, files simplified, key changes made
3. List any files that couldn't be simplified and why

Constraints

• NEVER change functionality - only improve how code is written
• All original features and behaviors must remain intact
• Skip generated files, vendored code, and config files
• If uncertain about a change, skip it