What are key software design principles (DRY, KISS, YAGNI)?

Question

Accepted Answer

Beyond specific patterns, **design principles** like **DRY**, **KISS**, **YAGNI**, and others guide writing good code. These memorable principles capture fundamental wisdom about simplicity, avoiding duplication, and not over-building.

## Core principles

```text
DRY (Don't Repeat Yourself) → avoid DUPLICATION → each piece of knowledge has ONE
  authoritative representation (duplication → bugs/changes in many places)
KISS (Keep It Simple, Stupid) → favor SIMPLICITY → simple solutions are easier to
  understand, maintain, and debug (avoid unnecessary complexity)
YAGNI (You Aren't Gonna Need It) → don't build features/flexibility you don't NEED yet →
  avoid speculative generality (build what's needed, not what might be needed)
```

## Other important principles

```text
✓ SEPARATION OF CONCERNS → divide a system into distinct parts with clear responsibilities
✓ HIGH COHESION, LOW COUPLING → related things together; minimize dependencies between parts
✓ COMPOSITION over inheritance → prefer composing behavior over deep inheritance hierarchies
✓ LEAST ASTONISHMENT → code should behave as expected (no surprises)
✓ Encapsulation; single source of truth; fail fast; principle of least privilege
```

## Balancing principles

```text
⚠️ Principles can sometimes CONFLICT or be over-applied:
  → DRY vs simplicity → don't over-abstract to avoid tiny duplication (sometimes a little
    duplication is simpler than the wrong abstraction)
  → KISS/YAGNI vs flexibility → don't under-build genuinely-needed flexibility
→ apply principles with JUDGMENT and balance → they're guidelines, not absolute rules
```

## Why it matters

Understanding key software design principles is valuable senior-level knowledge because they capture **fundamental wisdom for writing good code** that applies across patterns and languages, so they're broadly important design guidance.

Principles like DRY, KISS, and YAGNI distill core software design wisdom into memorable, widely-referenced guidelines.

Understanding the **core principles** — **DRY** (avoiding duplication so each piece of knowledge has one authoritative representation, since duplication causes bugs and scattered changes), **KISS** (favoring simplicity since simple solutions are easier to understand, maintain, and debug), and **YAGNI** (not building features or flexibility you don't yet need, avoiding speculative over-engineering) — provides foundational guidance applicable everywhere.

Understanding **other important principles** — **separation of concerns**, **high cohesion and low coupling** (related things together, minimal dependencies between parts — fundamental to good design), **composition over inheritance**, least astonishment, encapsulation, and single source of truth — broadens the design wisdom.

Crucially, understanding **balancing principles** reflects mature judgment: principles can conflict or be over-applied (DRY vs simplicity — sometimes a little duplication is better than the wrong abstraction; KISS/YAGNI vs genuinely-needed flexibility — don't under-build what's truly needed), so they're **guidelines to apply with judgment, not absolute rules**.

This balanced understanding — knowing the principles but applying them thoughtfully rather than dogmatically — is the mark of mature design sense.

These principles are broadly applicable, language- and pattern-independent wisdom that guides writing good code.

Since these design principles (DRY, KISS, YAGNI, separation of concerns, low coupling) capture fundamental, broadly-applicable wisdom for writing good code, and since applying them with balanced judgment (recognizing they're guidelines that can conflict or be over-applied) reflects mature design sense, and since they're widely-referenced guidance, understanding key software design principles is valuable senior-level knowledge — fundamental, broadly-applicable wisdom for writing good code, important across patterns and languages, and reflecting the mature design judgment (knowing the principles and applying them with balance) expected of senior developers who write and guide good software design.