YAGNI — You Aren't Gonna Need It: Visual walkthrough

Step 1 — Draw the decision as two roads

WHAT. You are standing at a fork. A story just asked for feature X maybe being useful later. You can go Build-Now (write the speculative code today) or Wait (write nothing, revisit if a real ticket arrives).

WHY a fork and not a formula? Because YAGNI is a choice under uncertainty. Before any algebra we must be honest that we do not know the future — so we draw two possible roads, not one. A formula that pretended we knew the future would be lying.

PICTURE. Two roads leave one point. The Build-Now road is orange; the Wait road is blue. We will attach money-costs to each road in the next steps.

Figure — YAGNI — You Aren't Gonna Need It

Definition The quantities (each will get a picture)

$C_{build}$ = money/effort to write the speculative code today (a one-time lump).
$c$ = the daily cost of keeping that code alive — reading it, testing it, refactoring around it — even while nobody uses it. This is a per-day rate, not a lump.
$D$ = the number of days you carry the code before it is either used or scrapped. This is the time horizon.
$C_{carry} = c \cdot D$ = the total carry cost — the daily rate multiplied by how many days you carry it. This lump is what enters the inequality.
$p$ = probability the guess is right (the feature is truly needed, in the shape you imagined).
$C_{build}$ vs $C_{later}$ : $C_{later}$ = cost to build the feature later, when a real requirement exists — usually less than $C_{build}$ .
$S$ = the saving you collect if the guess is right. Building now lets you skip the later build, so the saving is exactly $S = C_{later}$ (the later-build cost you avoid). We will pin this down precisely in Step 6.

Step 2 — Put the certain costs on the Build-Now road

WHAT. Walk down the Build-Now road. The instant you take it you spend $C_{build}$ (you wrote the code). Then, for every day the code exists, you spend the daily rate $c$ . If you carry it for $D$ days, the daily rate stacks up to a total $c \cdot D$ .

WHY split them, and why count days? Because they have different units. $C_{build}$ is a one-time lump (dollars). $c$ is a rate (dollars per day) — you cannot add a rate to a lump until you multiply it by a number of days $D$ . This is the fix for the classic mistake of writing " $C_{build} + c$ ": that adds dollars to dollars-per-day, which is meaningless. We must first turn the daily trickle into a total lump $C_{carry} = c \cdot D$ .

PICTURE. One tall orange bar at day 0 ( $C_{build}$ ), then a row of $D$ short orange bars marching to the right ( $c$ each). The total shaded area of the short bars is $c \cdot D = C_{carry}$ .

$Certain cost = one lump, day 0 C_{build} + rate \times days = C_{carry} c \cdot D$

Step 3 — The reward only appears through a coin flip

WHAT. The Build-Now road has an upside, but you don't get it automatically. You get the saving $S$ only if the guess was right — probability $p$ . With probability $1 - p$ the guess was wrong and $S$ never arrives.

WHY a probability at all? Because "we might need it later" is literally a claim about an uncertain event. To reason about it we must attach a number $p$ between 0 and 1. $p = 1$ means "certain to be needed" (rare); $p = 0$ means "will never be needed"; real speculation lives near the small end.

PICTURE. The green reward $S$ sits behind a gate. A coin flip decides whether the gate opens. The gate opens only a fraction $p$ of the time — so on average you collect a shrunken reward $p \cdot S$ , drawn as a green bar scaled down by $p$ .

$Average reward = how often the gate opens p \times prize when it does S = p S$

Step 4 — Line up reward against cost: the break-even line

WHAT. Now put the average reward $p S$ (green, from Step 3) next to the certain cost $C_{build} + c \cdot D$ (orange, from Step 2). Building speculatively is only worth it when green beats orange.

WHY compare exactly these two? Because the Wait road pays nothing today. So Build-Now is justified only if its net average payoff is positive — reward minus certain cost above zero.

PICTURE. A see-saw. Green $p S$ on the left pan, orange $C_{build} + c \cdot D$ on the right. The dashed gray line is break-even: the tipping point where the two are equal.

Step 5 — Why the inequality almost always FAILS

WHAT. Plug in what real software actually looks like: $p$ is small (requirements drift, you guessed the shape wrong), and the carry total $c \cdot D$ grows with time — the longer you sit on unused code, the bigger it gets.

WHY these values? Because imagined requirements rarely arrive as imagined, so $p$ hugs the low end. And carried code is read and maintained for many days, so $D$ is large and $c \cdot D$ keeps climbing.

PICTURE. As $p$ slides from 1 down toward 0, the green reward bar shrinks. There is a threshold $p^{⋆}$ where green drops below orange — the break-even $p$ . Everything to the left of $p^{⋆}$ (small $p$ ) is YAGNI territory: don't build.

$p^{⋆} = \frac{C _{build} + c \cdot D}{S} build only if p > p^{⋆}$

What $p^{⋆}$ is doing: it is the minimum success-probability that would justify the bet. Below it, the certain costs swallow the average reward.
Because the carry total $c \cdot D$ lives in the numerator, every extra day $D$ of carrying the code pushes $p^{⋆}$ higher — making the bet harder to win the longer the code sits unused. Time is working against you.

Step 6 — The hidden bonus: waiting makes the future job cheaper (and pins down $S$ )

WHAT. Recall $S = C_{later}$ : the saving from building now is exactly the later-build cost you avoid. Now the key fact — building later usually costs less than building now: $C_{later} < C_{build}$ . When you finally build it for a real ticket, you know the true requirement — no wrong guesses, no rework.

WHY does knowing the requirement cut cost? Speculative building pays twice: once to build the guessed version, and again to fix it when reality differs. Waiting skips the wrong first version entirely.

PICTURE. Two orange bars for "build the feature": the speculative one is tall ( $C_{build}$ = guess + rework); the informed-later one is short ( $C_{later}$ ). The gap is pure waste avoided by waiting.

Step 7 — The degenerate cases (never leave a gap)

WHAT. Check the corners so no scenario surprises you.

WHY corners matter. A rule you only trust in the middle is a rule you don't understand. YAGNI must survive $p = 0$ , $p = 1$ , $D = 0$ , $D \to \infty$ , and the "needed now" case.

PICTURE. Four mini-panels, one per corner, each showing which road wins.

Corner	What it means	Verdict
$p = 0$	Guaranteed never needed	Green pan empty → never build. Pure waste.
$p = 1$	It's certainly needed	Then it's not speculation — it's a present requirement. Build it (this is Example 3: validation, auth).
$D = 0$	Code is used or scrapped immediately, no carry	Then $c \cdot D = 0$ : even a small reward can justify it. But truly zero-day carry almost never exists.
$D \to \infty$	Code is carried forever (never used, never scrapped)	$c \cdot D$ grows without bound → certain cost dominates → always a bad bet. The worst case, and the common one for speculative hooks.

The one-picture summary

Everything above collapses into one graph: the average payoff of Build-Now as $p$ rises from 0 to 1, with the break-even threshold $p^{⋆} = (C_{build} + c \cdot D) / S$ marked. Left of $p^{⋆}$ (the wide YAGNI zone) → wait. Right of it → build. Two forces push $p^{⋆}$ rightward — a bigger carry total $c \cdot D$ (more days $D$ ) and a cheaper $C_{later}$ shrinking $S$ — so real speculation lives far to the left, which is why YAGNI almost always says no.

Recall Feynman: tell the whole walkthrough to a friend

You're at a fork: build the "might-need-it" thing now, or wait. If you build now you pay a big up-front cost plus a small fee every single day the code just sits there — and you have to count the days: multiply the daily fee by how long you'll carry it before it's used or thrown away. The payoff is a prize you might win, and the prize is just the money you'd save by not building it later — so its real average worth is that later-build cost, shrunk by how rarely you'll actually collect it. Line the shrunken prize up against the up-front cost plus the day-by-day total. Now the punchline: the chance of guessing right is small, the daily fee runs for many days, and the later build is cheaper than building now — so the prize side is small and the cost side is big. The contest is almost always a loss. Don't build it. The only exceptions are the corners — when the thing is certainly needed right now, it's not a guess anymore, it's today's job, and you build it well.

Connections

Parent: YAGNI — the note this page derives.
Rule of Three — the trigger for the cheaper "build later" of Step 6.
KISS — Keep It Simple — governs the $p = 1$ "needed now" corner: build it, simply.
Premature Optimization — same small- $p$ bet, performance flavor.
DRY — Don't Repeat Yourself — abstracting on first duplication is a tiny- $p$ bet too.
Extreme Programming — where the inequality's discipline comes from.
Technical Debt — speculative code is pre-paid debt with an empty green pan.
Simplicity — the fewer roads you take, the less bill you carry.