The first time, the slow way — by hand, the way I used to build everything. Typing most of it, reaching for the AI only when I got stuck. It took most of a week of evenings.
Then, a month later, half out of boredom, I threw the whole thing away and rebuilt it from scratch. Same features, same spec. Except this time I let the AI do the writing. I described what I wanted, it produced, I steered. It took an afternoon.
The second version is better. Cleaner code, fewer rough edges, more consistent naming. It even passed a couple of edge-case tests the first one didn't. By every number you'd put on a dashboard, the AI version won, and it wasn't close.
That gap is the whole thing I've been chewing on since, because it isn't supposed to exist. Better code is supposed to earn more trust, not less. Mine did the exact opposite.
I went in assuming trust would track quality. Write better code, trust it more — obviously. The AI version is higher quality. So why do I open the hand-built one with ease, and open the AI one with a small flinch, every time?
The faster I built, the less I knew where it would break. Those two moved together, in the wrong direction, and once I saw it I couldn't unsee it. Which means trust was never a property of the code at all. It was a property of something else — something the fast version skipped without telling me.
When I built version one by hand, I ended up with something that never made it into the repo: a map.
I knew which parts were load-bearing and which were duct tape. I knew the one function that quietly assumed the list was already sorted. I knew the exact spot where, if the same request came in twice, something ugly happened. Nobody wrote any of that down. It lived in my head, and I'd built it without noticing — one decision at a time, because every one of those lines had made me pause. Ack here, or after the save? Trust this input, or validate it? What happens if this gets called twice? Each pause left a little pin in a mental map of where the bodies were buried.
That map is what trust is. Not "the code is correct" — I can't actually prove that about either version. Trust is "I know where this breaks." I had that map for version one. I did not have it for version two, and no amount of the AI's cleaner code was going to give it to me.
For years I thought the value of writing code by hand was the code. The craft. The output. It wasn't. The AI writes better code than my hands do — version two settled that argument. The typing was a side effect. What the typing secretly produced was the map. Every keystroke was a small decision, and the decisions were the thing I was really accumulating.
I thought I was manufacturing code. I was manufacturing the knowledge of where it breaks, and the code was the byproduct. AI handed me the byproduct for free and quietly kept the thing I actually needed.
In both versions there's a write path that acknowledges the request before it persists the row. In version one, I remember writing that line. I remember pausing on it. I remember moving the ack down below the save, because some part of me went cold when I looked at the order.
That cold feeling has a source. Years ago I shipped exactly that bug — a write path that told the client "got it" before it had saved anything. The code was clean, idiomatic, tested, green. Then one ordinary day a retry hit at the wrong moment: the "got it" went out, the save never landed, and a paying customer got locked out of their own account with nothing in the logs to say they'd ever been there. Ack before persist. I can still feel the phone call.
So when I typed that line by hand in version one, the scar fired, and I fixed the bug before it existed.
In version two, the AI wrote the same line — ack before persist — confidently, cleanly, and I scrolled right past it. Not because I'd gotten dumber in a month. Because I never typed it. The decision never passed through me, so the scar never got its chance to fire.
That's the moment it clicked. The typing wasn't only building the map. It was the checkpoint — the turnstile every line used to pass through, where each of my scars got a vote on the way in. Automate the typing and you don't just lose the map. You remove the one place my judgment used to get consulted automatically, for free, on every single line.
I'm not telling you to go back to typing everything. I shipped version two, not version one. The AI code is better and I'd never hand-roll that app again. The typing was never worth defending for its own sake.
That's actually the trap: thinking the fix is to slow down and type more, like the keystrokes were sacred. They weren't. The problem isn't that the AI writes the code. The problem is that we got the code and assumed the map came stapled to it — the way it always had, for twenty years, because for twenty years you couldn't get the code without doing the work that produced the map.