Why One Person Can Build What It Used to Take Five

Design discipline, not agent speed, is what lets AI multiply a solo builder instead of just multiplying their mistakes.

Leer esto en español

April 22, I wrote the first line of code; April 23, Night Shift was live and taking real money — a financial app for people who get paid in cash and tips, built by one person in a day. The first version took a day. Making it trustworthy took the ninety days since — roughly seven hundred commits, solo.

The math everyone gets wrong about AI and speed

Most people hear "one person can now do what used to take five" and assume it's about typing speed. Wrong problem. John Ousterhout teaches software design at Stanford, and in a talk on the subject, he draws a line between two kinds of programmers.

Tactical programmers optimize for something working, right now. Strategic programmers pay a design tax — Ousterhout puts the affordable range around ten to twenty percent of your time — so the system stays fast to change later.

The tactical approach feels faster, for a while. Then the bill comes due, because, in Ousterhout's words, "complexity isn't one mistake you make" — it's thousands of small ones, made by whoever was in a hurry that week.

The extreme version of that person is what he calls a tactical tornado: someone who ships enormous volumes of eighty-percent-working code, gets celebrated for the speed, and leaves the mess for whoever comes next. Hand that person an agent fleet and you haven't fixed the tornado. You've given it four more hands.

What a deep interface looks like

Ousterhout's best example of good design is UNIX file input and output: five functions — open, read, write, close, seek — hiding hundreds of thousands of lines of disk management, caching, and driver code that most programmers never think about again. That's a deep interface: a small opening onto an enormous room. Most software fails this test in the opposite direction, an interface nearly as complicated as the thing it's supposedly hiding.

Night Shift is the version of that idea I actually had to build. Every screen, every notification, every email ships in English and Spanish — fifty-three English files, fifty-three Spanish files — and the deploy fails outright if the two drift out of sync. The interface is one sentence: it works in both languages, always; everything Ousterhout would call the real complexity sits underneath that sentence, exactly where it should.

The part that looks like failure

Not everything in those ninety days was forward motion. Partway through, I'd built a second version of Night Shift — hundreds of commits, seventeen hundred tests — a real upgrade on paper over the version people actually used. It was out-engineering the demand in front of it.

So I parked it — not deleted, parked — and went back to hardening the version people already depended on. The product didn't need a better engine. It needed more people in it.

Framed another way, it's real time spent on something nobody asked for. I don't have a clean answer for which framing is true. Probably both.

What actually multiplies

This is where the two threads meet. An agent fleet doesn't make you strategic. It makes whatever you already are happen faster.

Hand a tactical tornado five agents and you get five tornadoes running at once, each shipping eighty-percent-working code faster than any human tornado could alone — five wakes of damage instead of one.

Hand that same discipline — paying the design tax, keeping interfaces deep and boring on the outside — an agent fleet, and something different happens. The overhead that used to make strategic programming a hard sell, because it's slower up front and slower is a hard sell to anyone paying by the sprint, stops being the bottleneck.

The agents absorb the volume. The discipline decides what the volume is for.

That's the actual math behind one person doing what used to take five. Not five times the typing. A decomposition instinct that used to run at one person's pace, now with five agents' worth of throughput behind it.

What I still don't know

Ousterhout says the gap between an average programmer and a 10x programmer is real, well known in the field, and never deliberately taught. Nobody sits you down and teaches decomposition the way someone teaches a for-loop.

So here's what I don't have a tidy ending for. If the discipline that makes agents multiply you instead of your damage isn't something a class teaches, and it isn't something an agent teaches either, I don't know how the next person gets it before their own version of the ninety days.

Maybe you don't get to skip them. Maybe that's just the cost of the ten to twenty percent, paid once, in a currency no fleet of agents can pay on your behalf.