KISS (Keep It Simple, Stupid)
Overview
The simplest solution that works is the best solution.
Clever code impresses no one. Simple code ships faster, breaks less, and others can maintain it.
When to Use
-
Solution feels complex
-
Writing "elegant" or "clever" code
-
Multiple approaches exist
-
Tempted to show off skills
-
Using advanced patterns for simple problems
The Iron Rule
NEVER choose clever over clear. Simple wins.
No exceptions:
-
Not for "it's more elegant"
-
Not for "it shows advanced skills"
-
Not for "it's technically better"
-
Not for "it's a nice one-liner"
Detection: The "Clever" Smell
If you're proud of how clever your code is, simplify it:
// ❌ VIOLATION: Clever one-liner const isPalindrome = (s: string): boolean => (s = s.toLowerCase().replace(/[^a-z0-9]/g, '')) === [...s].reverse().join('');
// ✅ CORRECT: Simple and clear function isPalindrome(str: string): boolean { const cleaned = str.toLowerCase().replace(/[^a-z0-9]/g, '');
for (let i = 0; i < cleaned.length / 2; i++) { if (cleaned[i] !== cleaned[cleaned.length - 1 - i]) { return false; } }
return true; }
The Cost of Complexity
Complex Code Impact
Clever one-liners Unreadable, hard to debug
Nested ternaries Logic becomes opaque
Over-abstraction Indirection hides intent
Premature optimization Complexity without measured benefit
Design pattern overuse Patterns for patterns' sake
Correct Pattern: Obvious Code
Write code that a junior developer can understand in 30 seconds:
// ❌ COMPLEX: "Elegant" functional chain const result = data .filter(Boolean) .map(x => transform(x)) .reduce((acc, x) => ({ ...acc, [x.id]: x }), {}) .values() .filter(x => x.active) .sort((a, b) => b.date - a.date) .slice(0, 10);
// ✅ SIMPLE: Clear steps with names const validItems = data.filter(Boolean); const transformed = validItems.map(transform); const activeItems = transformed.filter(item => item.active); const sorted = activeItems.sort((a, b) => b.date - a.date); const topTen = sorted.slice(0, 10);
Pressure Resistance Protocol
- "It's More Elegant"
Pressure: "This one-liner is more elegant than the verbose version"
Response: Elegance is clarity, not brevity. Simple code is more elegant than clever code.
Action: Use the clear version. Name intermediate variables.
- "It Shows Advanced Skills"
Pressure: "I want to demonstrate I know advanced patterns"
Response: Senior engineers are recognized for simple solutions, not complex ones.
Action: Solve the problem simply. Save cleverness for where it's needed.
- "It's Technically Better"
Pressure: "The complex version is O(n) vs O(n log n)"
Response: Premature optimization. Is this actually a bottleneck?
Action: Write simple code. Optimize only when profiling shows need.
- "Let Me Show Multiple Approaches"
Pressure: "I'll provide two implementations to show versatility"
Response: One clear solution is better than multiple options.
Action: Pick the simplest approach. Provide only that.
Red Flags - STOP and Reconsider
If you notice ANY of these, simplify:
-
Code requires explanation comments
-
Nested ternaries ? : ? :
-
Multiple chained operations (5+)
-
Regex that needs decoding
-
Proud of how clever it is
-
"One-liner" implementations
-
Junior couldn't understand in 30 seconds
-
Multiple solutions "for versatility"
All of these mean: Rewrite simply.
Simplification Techniques
Complex Simple
Nested ternaries if/else statements
Long chains Named intermediate variables
Clever regex Multiple simple checks
One-liner Multi-line with comments
Implicit Explicit
Magic numbers Named constants
Quick Reference
Symptom Action
"Elegant" one-liner Expand to clear multi-line
Nested ternary Convert to if/else
Complex chain Break into named steps
Multiple approaches Pick simplest one
Pride in cleverness Rewrite simply
Common Rationalizations (All Invalid)
Excuse Reality
"It's more elegant" Clear code is more elegant than clever code.
"Shows advanced skills" Simple solutions show more skill.
"It's a nice one-liner" One-liners are often unreadable.
"Technically better" Premature optimization is bad.
"Multiple options show versatility" One clear solution is better.
"It's how experts do it" Experts write simple code.
The Bottom Line
Simple beats clever. Clear beats concise. Obvious beats elegant.
When solving a problem: find the simplest solution that works. If a junior dev can't understand it in 30 seconds, simplify it.