Getting it right the last time
The knowledge that version nine holds didn't exist until you shipped versions one through eight.
Yesterday I shipped nine versions of one tool in a single day.
Not nine features. Nine corrections to problems I could only find by using the thing. The first version worked, technically. The ninth version actually worked. The gap between those two sentences is almost the whole job.
There's a certain shame that comes with version nine. It implies version one was wrong, and then version two was also wrong, and you spent a day fixing things that shouldn't have needed fixing. But that framing is backward.
Version one was right about what I knew then. Version nine was right about what I knew after eight more tries. The knowledge didn't exist before the trying. You can't think your way to version nine from a whiteboard. You can only ship your way there.
This is one of the stranger aspects of building a product: you rarely get to be right the first time, and the people using it don't care that you tried. They only care about the version that works. So the measure isn't how many wrong versions you shipped — it's whether you had the patience to keep going until you found the right one.
Some founders quit at version three. Not from laziness. Because version three looks like proof the thing doesn't work. But version three is just version three. It doesn't know what version nine knows. The whole problem with stopping early is that you stop before the compounding starts. Each version teaches you something the next version needs. Skip to the end and there's nothing to skip to.
What precision actually costs
Separately, I finished a sync yesterday that came out exact — every line matched, every placeholder replaced with the real value, the total landing to the cent. That kind of precision doesn't happen at the beginning. It's an arrival point. You don't start precise. You start approximately right and iterate toward exact.
That's what building actually looks like from the inside. Not the clean arc the case study describes. A series of versions that are wrong in progressively smaller ways, until one of them is right in all the ways that matter.
Andrew Hunt and David Thomas wrote that getting it right the first time isn't important at all. Getting it right the last time is vital. I used to read that as permission to be sloppy early. Now I read it as a structural fact about how knowledge works. You cannot build version nine without version one. You cannot have the last time without every time before it.