Code Simplifier

What I do

I analyze code and automatically simplify it by:

• Extracting repetitive code patterns into reusable functions
• Removing redundant code, dead code, and unnecessary complexity
• Applying idiomatic language patterns and best practices
• Optimizing control flow and data structures
• Improving readability while preserving functionality

When to use me

Use this skill when you need to:

• Clean up legacy code with high complexity
• Extract common patterns into helper functions
• Reduce code duplication across files
• Modernize code to follow current best practices
• Simplify nested conditionals and loops
• Improve variable naming and code structure

My workflow

1. Code Analysis

   • Parse the code into abstract syntax tree (AST)
   • Identify code clones and repeated patterns
   • Measure cyclomatic complexity
   • Detect dead code and unreachable branches
   • Find anti-patterns and suboptimal constructs

2. Simplification Strategies

   • Extract methods/functions from duplicated code
   • Replace nested conditionals with guard clauses
   • Simplify boolean expressions
   • Merge similar switch/if branches
   • Convert loops to iterator methods where applicable
   • Remove unused imports, variables, and functions

3. Refactoring Execution

   • Apply changes incrementally, preserving git history
   • Maintain function signatures and behavior
   • Add minimal, focused unit tests for extracted functions
   • Update documentation for changed public APIs

4. Validation

   • Ensure all existing tests still pass
   • Verify no semantic changes were introduced
   • Check that complexity metrics improved

Usage

/simplify --file src/utils/helper.ts
/simplify --dir src/components --recursive
/simplify --pattern "**/*.java" --dry-run
/simplify --aggressive --max-complexity 10

Options

What I won't do

• Change public API signatures without explicit approval
• Modify code that doesn't have test coverage
• Introduce behavioral changes (only refactoring)
• Remove code comments (only unused imports/variables)
• Force a specific coding style beyond simplification

Simplification Examples

1. Code Extraction

Before:

// Duplicate code in multiple places
const calculateTax = (amount: number) => amount * 0.08;
const calculateShipping = (weight: number) => weight * 0.5;
const calculateDiscount = (price: number) => price * 0.1;

// Later in the file...
const calculateTax = (amount: number) => amount * 0.08;
const calculateShipping = (weight: number) => weight * 0.5;
const calculateDiscount = (price: number) => price * 0.1;

After:

const calculateTax = (amount: number) => amount * 0.08;
const calculateShipping = (weight: number) => weight * 0.5;
const calculateDiscount = (price: number) => price * 0.1;

// Used where needed

2. Guard Clauses

Before:

function processUser(user: User): Result {
    if (user !== null) {
        if (user.isActive) {
            if (user.hasPermission) {
                // Main logic
                return performAction(user);
            }
        }
    }
    return defaultResult;
}

After:

function processUser(user: User): Result {
    if (!user || !user.isActive || !user.hasPermission) {
        return defaultResult;
    }
    return performAction(user);
}

3. Boolean Simplification

Before:

const isValid = (status: string) => {
    if (status === 'active' || status === 'pending') {
        return true;
    } else {
        return false;
    }
};

After:

const isValid = (status: string) => status === 'active' || status === 'pending';

4. Loop to Iterator

Before:

const names: string[] = [];
for (let i = 0; i < users.length; i++) {
    names.push(users[i].name);
}

After:

const names = users.map(user => user.name);

5. Optional Chaining & Nullish Coalescing

Before:

const city = user && user.address && user.address.city !== null
    ? user.address.city
    : 'Unknown';

After:

const city = user?.address?.city ?? 'Unknown';

Complexity Metrics

Best Practices

1. Extract early, extract often: Don't wait for duplication to grow
2. Single Responsibility: Each function should do one thing well
3. Small functions: Aim for < 20 lines per function
4. Descriptive names: calculateTotalWithTax() > process()
5. Avoid side effects: Pure functions are easier to test and reason about

Limitations

• Cannot simplify code without clear structure (e.g., generated code)
• May require human review for domain-specific optimizations
• Some patterns are intentionally complex for performance reasons
• Tests must exist for behavioral verification

Output Format

Summary Report

# Code Simplification Report

## Changes Applied

### Extracted Methods
- `extractUserData()` from 3 locations
- `validateInput()` from 2 locations

### Removed Dead Code
- Unused function: `legacyProcess()`
- Unreachable branch in `handleEvent()`

### Simplified Conditionals
- Replaced nested ifs with guard clause (5 occurrences)
- Simplified boolean expressions (3 occurrences)

## Metrics Improvement

| Metric | Before | After | Change |
|--------|--------|-------|--------|
| LOC | 1,250 | 980 | -22% |
| Complexity | 18 avg | 11 avg | -39% |
| Functions | 45 | 52 | +16% |

## Files Modified

- src/utils/helper.ts (3 changes)
- src/services/user.ts (2 changes)
- src/components/form.tsx (1 change)

Interaction style

• Provide clear before/after code comparisons
• Explain the rationale for each simplification
• Suggest additional manual improvements when applicable
• Warn about potential risks before aggressive changes
• Preserve code comments and documentation
• Group related changes into logical commits

Quick Reference

Converted and distributed by TomeVault — claim your Tome and manage your conversions.