Simplify Code — Reduce Unnecessary Complexity
The best code is the code you don't have to write. The second best is the code anyone can read.
Core Principle
Complexity is a cost. Every abstraction, every indirection, every clever pattern
adds cognitive load. Simplify ruthlessly unless complexity serves a clear purpose.
Simplification Checklist
1. Unnecessary Abstractions
| Smell |
Simplification |
| Wrapper class that just delegates |
Remove wrapper, use the inner class directly |
| Factory that creates only one type |
Replace with direct constructor |
| Strategy pattern with one strategy |
Replace with simple function |
| Interface with one implementation |
Remove interface, use the class |
| Abstract class with one child |
Merge into the child class |
| Config object for 2 values |
Use function parameters |
2. Dead Code
| Smell |
Action |
| Unused imports |
Remove |
| Unreachable branches |
Remove (check tests first) |
| Commented-out code |
Remove (it's in git history) |
| Unused variables/functions |
Remove |
| TODO comments older than 6 months |
Remove or create issue |
| Feature flags for launched features |
Remove flag, keep the code |
3. Deep Nesting
// ❌ Before: 4 levels deep
function process(data) {
if (data) {
if (data.items) {
for (const item of data.items) {
if (item.active) {
doSomething(item)
}
}
}
}
}
// ✅ After: Early returns + filter
function process(data) {
if (!data?.items) return
data.items
.filter(item => item.active)
.forEach(doSomething)
}
4. Over-Parameterized Functions
// ❌ Before: 8 parameters
function createUser(name, email, age, role, dept, active, verified, avatar) { }
// ✅ After: Object parameter
function createUser(opts: CreateUserOpts) { }
5. Premature Optimization
| Smell |
Simplification |
| Custom cache for <100 items |
Remove cache, measure first |
| Memoization on cheap functions |
Remove memo |
| Lazy loading for small modules |
Use direct import |
| Complex state machine for 3 states |
Use simple if/else or switch |
Simplification Protocol
Step 1: Identify Complexity
- Count nesting levels (target: ≤3)
- Count function parameters (target: ≤4)
- Count lines per function (target: ≤30)
- Count abstractions per feature (target: ≤2)
- Check for dead code (target: 0)
Step 2: Verify Understanding
Before simplifying, ensure you understand:
- What the code does (not what it looks like it does)
- Why it was written this way (maybe there's a reason)
- What tests cover it (simplification must not break tests)
Step 3: Simplify Incrementally
1. Remove dead code first (safest)
2. Flatten nesting with early returns
3. Inline trivial abstractions
4. Merge related functions
5. Simplify data structures
Step 4: Verify Behavior Preserved
npm run test # All existing tests still pass
npm run build # Still compiles
When NOT to Simplify
| Situation |
Why Keep Complexity |
| Performance-critical hot path |
Optimization may look complex but is necessary |
| Required by framework/library |
External constraints |
| Explicitly requested pattern |
User chose this architecture |
| Will need extension soon |
Abstraction prepares for known growth |
Ask first: "This pattern seems over-engineered. Should I simplify it, or is there a reason for the abstraction?"
vudovn