KISS Principle

Keep It Simple, Stupid — a design principle stating that systems work best when they are kept simple rather than made complex. Attributed to Kelly Johnson of Lockheed Skunk Works, who challenged his engineers to design jet aircraft maintainable by an average mechanic with basic tools under combat conditions. The constraint forced simplicity, and the result was some of the most reliable aircraft ever built.

In software, KISS means choosing the simplest solution that correctly solves the problem. This is not about writing naive code — it is about resisting unnecessary abstraction, premature generalization, and architectural complexity that does not serve a current, concrete need.

Key Principles

Simplicity is a feature. Simple code is easier to read, test, debug, and modify. Every layer of indirection, every abstraction, every configuration option is a maintenance cost. That cost must be justified by a real benefit, not a hypothetical one.

Complexity is a spectrum. A function with three if-statements is simpler than one with a strategy pattern, even if the strategy pattern is “more elegant.” Choose the simplest construct that handles the actual requirements.

Signs of unnecessary complexity:

• Abstractions used in only one place
• Configuration for behavior that never varies
• Wrapper classes that add no behavior
• Generic solutions to specific problems
• Framework-level architecture for application-level problems

Relationship to Other Principles

KISS complements DRY — but they can conflict. Extracting duplication sometimes introduces indirection that makes code harder to follow. When DRY and KISS conflict, prefer KISS for code that is read far more than it is changed, and DRY for knowledge that changes frequently.

KISS is closely related to YAGNI — both resist doing more than is needed. KISS focuses on how (implementation simplicity), while YAGNI focuses on what (feature scope).

Common Mistakes

• Interpreting KISS as “write dumb code” — the goal is clarity, not naivety
• Applying KISS selectively while allowing complexity elsewhere in the same system
• Using KISS to justify avoiding necessary complexity (e.g., proper error handling, security measures)

References

• Johnson, K. (1985). Kelly: More Than My Share of It All. Smithsonian Books.
• Martin, R. C. (2008). Clean Code. Chapter 12: Emergence.