name: keep-it-simple
description: Use when tempted to write clever code. Use when solution feels complex. Use when showing off skills instead of solving problems.

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

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

1. "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.

2. "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.

3. "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.

4. "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

Quick Reference

Common Rationalizations (All Invalid)

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.