DRY, KISS, YAGNI in tension

DRY is about knowledge, not text. The “Don’t Repeat Yourself” principle, as originally stated, is: every piece of knowledge must have a single, authoritative representation in the system. The unit is a piece of knowledge — a business rule, a calculation, a policy — not a run of characters that happen to look the same. Two snippets can be byte-for-byte identical and still not be a DRY violation, because they encode two different pieces of knowledge that merely coincide today.

// Both compute "is this value present and non-empty". Same TEXT.
function isValidUsername(s: string): boolean {
  return s != null && s.trim().length > 0;
}
function isValidComment(s: string): boolean {
  return s != null && s.trim().length > 0;
}

These look like duplication. But “what makes a username valid” and “what makes a comment valid” are two separate rules that happen to agree right now. The moment usernames need a max length and comments need a profanity filter, the shared version fractures. DRY does not apply here, because there is no single piece of knowledge — there are two.

The real test of duplication is: do these change for the same reason? This is the operational form of DRY. If a single decision in the business would force you to edit both fragments together, they encode one piece of knowledge and belong in one place. If a change to one would leave the other correct, they are independent and must stay apart.

// TRUE duplication: one rule, the 20% VAT rate, written twice.
const invoiceTotal = subtotal * 1.2;      // in invoice.ts
const quoteTotal   = estimate * 1.2;      // in quote.ts

Here the 1.2 is the same fact — the VAT rate — expressed twice. When VAT changes to 22%, both must change, together, for the same reason. That is true duplication: name it once (vatRate, applyVat()) and both sites depend on the one source. The literal looking identical is incidental; what matters is that one decision drives both. Same shape can be coincidence; same reason to change is duplication.

KISS and YAGNI are the counterweights that stop DRY from over-firing. DRY, taken alone, has an obvious failure direction: unify aggressively and you couple things that were independent. KISS (“keep it simple — the simplest thing that works”) and YAGNI (“you aren’t gonna need it — don’t build for needs you don’t have yet”) pull the other way. They are not in opposition to DRY by accident; they exist precisely to bound it.

// YAGNI violation born from "DRY-ing ahead": a generic engine for ONE caller.
function process<T>(
  items: T[],
  opts: { parallel?: boolean; retries?: number; transform?: (x: T) => T; dedupe?: boolean },
): T[] { /* 60 lines of branching nobody currently exercises */ }

// What was actually needed today:
const result = items.map(normalize);

The generic process is “DRY” in the sense that it could absorb future callers — but none of those callers exist. KISS says: write the .map(normalize). YAGNI says: don’t build the options bag for needs you can’t yet name. The flexibility is a guess, and every branch is code to read and a place for bugs while it sits unused.

The failure mode: DRY-ing coincidental duplication produces the wrong abstraction — a shared helper that sprouts a flag per caller. This is the most expensive of the three failures because it looks like good work. You see two similar blocks, extract a shared() helper, feel virtuous. Then caller A needs a slightly different behaviour, so you add a boolean. Caller B needs another tweak, so you add a second boolean. Each caller passes its own combination of flags; the helper’s body becomes a thicket of if (mode === ...). You now have something worse than the duplication you removed: a single function coupling unrelated callers, where a change for caller A risks breaking caller B.

// The wrong abstraction, fully grown:
function renderRow(item: Item, opts: {
  asAdmin?: boolean; compact?: boolean; forEmail?: boolean; legacyV1?: boolean;
}): string {
  // every combination of flags is a different caller's real requirement,
  // tangled into one body. Changing the email path can break the admin path.
}

Sandi Metz’s rule of thumb captures the escape: prefer duplication over the wrong abstraction. When an extracted helper starts growing per-caller flags, that is the signal the callers were never the same knowledge. The cheaper move is to inline it back — re-duplicate — and let each caller be simple and independent again. Duplication is far cheaper to fix later than a wrong abstraction everyone now depends on.