Files
Rohit Ghumare c3f43d8b61 Expand toolkit to 135 agents, 120 plugins, 796 total files
- Add 60 new agents across all 10 categories (75 -> 135)
- Add 95 new plugins with command files (25 -> 120)
- Update all agents to use model: opus
- Update README with complete plugin/agent tables
- Update marketplace.json with all 120 plugins
2026-02-04 21:08:28 +00:00

1.7 KiB

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.