Simplify

Simplify complex code by reducing nesting, eliminating duplication, and improving clarity.

Steps

1. Measure the current complexity:
   • Count nesting depth (target: max 3 levels).
   • Count lines per function (target: max 30 lines).
   • Identify duplicated patterns (3+ occurrences).
   • Check cyclomatic complexity if tooling available.
2. Apply simplification techniques:
   • Early returns: Replace nested if/else with guard clauses.
   • Extract variables: Name complex expressions for readability.
   • Decompose conditionals: Move complex conditions into named functions.
   • Replace loops: Use map/filter/reduce where clearer.
   • Eliminate duplication: Extract repeated patterns into shared functions.
   • Simplify state: Reduce the number of mutable variables.
3. For each simplification:
   • Show the before and after code.
   • Explain why the change improves the code.
   • Verify behavior is preserved.
4. Run tests after all simplifications.
5. Measure the new complexity and compare to the original.

Format

Simplification Report: <file>

Before: <complexity metrics>
After: <complexity metrics>

Changes:
  1. <description>: reduced nesting from 5 to 2 levels
  2. <description>: extracted 3 duplicated blocks into shared function
  3. <description>: replaced nested ternary with lookup table

Tests: all passing

Rules

• Never change behavior while simplifying; this is purely structural.
• Simplify the most complex functions first for maximum impact.
• Preserve meaningful variable names; do not over-abbreviate.
• Run tests after each simplification to catch regressions early.
• Do not simplify code that is intentionally optimized for performance.