KISS — Keep It Simple, Stupid: simplicity as a design goal

Definition

KISS — Keep It Simple, Stupid — is the design principle that systems work best when they are kept as simple as possible. Complexity is not a sign of sophistication; it is a liability. Every unnecessary abstraction, indirection, or clever trick is future maintenance burden. KISS does not mean "write naive code"; it means solving the actual problem at hand with the least structural complexity required.

In Practice

<?php
// OVER-ENGINEERED: a full strategy/factory pattern for a two-branch decision
interface GreetingStrategy
{
    public function greet(User $user): string;
}

class FormalGreeting implements GreetingStrategy
{
    public function greet(User $user): string
    {
        return "Good day, {$user->name}.";
    }
}

class CasualGreeting implements GreetingStrategy
{
    public function greet(User $user): string
    {
        return "Hey {$user->name}!";
    }
}

class GreetingFactory
{
    public function make(User $user): GreetingStrategy
    {
        return $user->isPremium() ? new FormalGreeting() : new CasualGreeting();
    }
}

// KISS: the actual problem doesn't warrant the machinery
function greetUser(User $user): string
{
    return $user->isPremium()
        ? "Good day, {$user->name}."
        : "Hey {$user->name}!";
}

KISS violations often stem from anticipating future requirements that never arrive (see YAGNI) or from applying design patterns as ends in themselves rather than as solutions to actual problems. In Laravel, KISS violations appear as service providers that register things you only use in one place, or repository interfaces wrapping a single Eloquent model with no alternative implementation planned.

In Context

Interviewers use KISS to evaluate judgment. A candidate who reaches for a pattern for every problem signals low judgment. The question "How would you implement this feature?" should be answered with the simplest thing that works correctly, with a note about what would prompt you to add structure. Structure should be earned by real complexity, not anticipated.

The frequent misunderstanding is that KISS conflicts with good design. It does not. A well-designed system is often simpler than a poorly designed one because good abstractions remove accidental complexity. KISS is specifically about not adding complexity that doesn't serve the problem — premature abstractions, speculative generality, and over-engineering all violate KISS without providing corresponding benefit.

Related terms: YAGNI (you aren't gonna need it — the companion to KISS about features), accidental complexity (complexity introduced by implementation choices, as opposed to essential complexity inherent in the problem), over-engineering (the failure mode KISS guards against), and refactoring (the tool for adding structure when complexity genuinely justifies it).