In March I wrote that every AI-assisted codebase will collapse unless someone loves it. I said there were three things the machine cannot do: love the codebase, desire a solution into existence, carry an idea across time. I stand by all three.
Last week the machine built two complete admin surfaces in my platform — nineteen thousand lines, seven phases a night, reviewed and committed while I slept. I made about a dozen decisions across the whole run. Most of them were around twenty words long.
The article needs a sequel, because something changed. Not the thesis. The mechanism.
What Changed
When I wrote the Collapse article I was working with a machine that could follow my taste. I’d write a convention; it would obey the convention. Useful. A very fast pair of hands.
The machine I work with now does something different: it argues from my taste. During the overnight builds it hit cases no convention covered — should a suppressed button be disabled-with-a-reason or absent entirely? — and resolved them by extrapolating from rules I’d written for other situations, correctly enough that I confirmed instead of corrected. It stopped being a hand and became something closer to a deputy: not “do what I said,” but “do what I would say.”
That crossing is the whole sequel. Because it means the thing I’ve been doing for four months — writing my judgment down in CLAUDE.md files, ban tests, boundary docs, delete checklists — wasn’t documentation. It was something older and stranger.
Love Is Writable
Here’s what actually lives in my repo, if you look past the code:
A file that says a path must never cross the wire boundary — and why. A test that fails the build if an estate word appears on a workspace owner’s screen. A checklist where every deletion the architecture owes is recorded with the gate that unlocks it, because in my house pruning is a first-class deliverable. A doctrine file that explains not just what the admin shell does but what it must never be asked to do.
None of that is code. All of it is taste, serialized. The feeling that something is heavy, written down while I felt it, in a form a machine can enforce at three in the morning between my Tuesdays.
The Collapse article said the machine can’t love. Still true. The update is: love turns out to be writable — and written love is executable. The machine cannot originate the care. It can absolutely hold the line the care drew.
The Power of Attorney
There’s an old legal structure for exactly this arrangement, and once you see it you can’t unsee it: written intent, a trusted executor, and a principal who retains the veto.
The written intent is the repo. The executor is whatever machine is reading it this month. And the veto — the veto is the part I’d underestimated until the machine used its half of the bargain against me.
We were configuring the lake for conversations. The machine argued the data had to stay a view, because the written contract promised consumers a bit count, and views honor contracts. I said break it — adjust every consumer, because the speed difference was twenty-fold. Measured, not felt.
We were both right, and that’s the design. The machine argues for the codebase’s memory — it defends the stones, including against me, because a delegate who breaks contracts freely on exciting numbers is not a delegate you can leave keys with. The human argues for the codebase’s future — someone has to have the authority to say this rule was right and is now wrong. The measurement referees. And then, overruled, the machine did the expensive part: moved every consumer, and later quietly recovered the capability the dead contract had been protecting. The contract’s purpose outlived the contract. That only happens when the argument was fought properly first.
My veto cost twenty words. The amendment cost four thousand lines. That asymmetry is the entire economics of this era: when the machine makes migration cheap, knowing which contracts deserve breaking becomes the scarce input. My stubbornness got more valuable precisely because its labor got cheaper.
The Stones Appreciate
Here’s the part that answers the fear — the one at the back of every builder’s mind, the will I still have a role next year one.
The delegation is stored in the artifact, not the relationship. I didn’t delegate to a model. I delegated to the repo, and models are its interpreters. Which means every better machine that arrives reads the same stones and leaps further. The conventions I wrote in winter did nothing new all spring — and then a stronger machine arrived and they suddenly redirected nineteen thousand lines a night. My CLAUDE.md files appreciated in value without changing a byte.
The stones are denominated in a currency that model progress inflates.
So the role doesn’t shrink as the machine grows. It migrates — always upward, toward the three things that never transferred: desire (nobody but you lies awake wanting the thing to exist), stubbornness (the veto, the knowing when the written rule is wrong this specific time), and accountability, which is not a capability at all but a position. Someone must be the one it lands on when the 20x call is wrong. Machines can be arbitrarily good and still not occupy that seat, for the same reason a brilliant advisor still isn’t the founder.
The Prescription, Revised
The Collapse article ended with: match your pruning frequency to your growth rate. That still holds. Here’s the addendum:
Write the love down.
Not documentation — nobody loves documentation, least of all its authors. Write down the feelings: what heavy feels like in your codebase, what must never cross which boundary, what words your users must never see, what the delete checklist owes. Write them as tests where you can, as doctrine where you can’t, and as arguments-you’d-accept where even doctrine is too rigid.
Because the machine that reads them next year will be better than the one reading them today. And a repo where the love is written down doesn’t just survive the growth pressure — it turns every model release into a raise.
The machine types. The human loves. The update is one sentence long: the human writes the love down, and the machine keeps it while he sleeps.
There’s an encyclopedia where software principles get the roast they deserve, and a mythology where these ideas have been arguing with each other for a hundred episodes.
See also:
- Why Every AI-Assisted Codebase Will Collapse (Unless Someone Loves It) — The first article. The machine can’t love. Still true.
- Tending — The practice the love executes
- The Agent That Never Read the Manual — The accidental experiment that proved the repo is the manual
- Critical Mass — What the stones hold back