Write Five, Keep One

I still remember a night, years ago, when I wrote a whole pile of code half asleep. I was sure I was onto something, so I kept going long past when I should have stopped. The next morning, with a fresh brain and a coffee, I re-read it — and it was pointed in completely the wrong direction. Not broken, just wrong: solving a problem I didn't actually have. I deleted all of it and felt like a failure, having wasted the sleep and the hours both, with nothing but throwaway code to show for the night.

We're trained to treat deleted code as failure — you wrote it, it took effort, and throwing it away feels like admitting the effort was wasted. That price collapsed. A working draft now costs minutes and a few cents. The scarce thing isn't the code anymore; it's the judgment about which code deserves to survive. And once you see that, the whole economics of your work inverts.

The right move now is to write five versions and keep one. Spike three designs before lunch and throw two away. Generate the entire feature two different ways and pick the one that reads better. Try the approach you're fairly sure is wrong, just to confirm it, because confirming it now costs almost nothing. The four you discard aren't waste — they're how you found the one worth keeping. A five-to-one ratio of abandoned to landed code shouldn't feel shameful. It should feel like exploration done right.

The trap is bringing expensive-code habits to cheap code. You see it everywhere now: someone pouring an hour of careful review into a throwaway spike, or growing attached to a branch precisely because the model spent so many tokens on it, or refusing to delete something that runs even though a better version is one prompt away. That's optimizing for a scarcity that no longer exists. The sunk cost was never real; now it's not even large.

This is the same lesson as knowing when to drop a near-finished project, pushed down to the level of the individual change. What you're actually producing was never the code. It was the decision — this design over that one, this shape over the four you tried. The code is just the residue of thinking, and cheap thinking means you can afford to think a lot more: out loud, in parallel, and then keep only the conclusion. So generate freely. Delete ruthlessly.