Two sermons
This autumn the loudest voices in programming split into two pulpits. From one, DHH told a hall of Rails developers that writing code by hand is over — no longer economically viable — and that despairing about it is for losers. From the other, a chorus of veterans warns that anyone who lets an AI read the stack trace, or take the first draft of anything unfamiliar, is quietly becoming replaceable: the model of the system must live in your head, or you are finished.
Both sermons share an assumption I don't accept: that the model of the system has to live in a human head at all.
A third answer
Mine doesn't live in my head. It lives in the sediment — the written record that accumulates where the work happens: commit history, specifications, the corpus my own site answers from. A head forgets, gets tired, retires, and cannot be searched. Sediment compounds. It can be read by me, by a collaborator, or by the next agent that opens the repository — identically, at 3 a.m., without me in the room.
This is not a metaphor I invented after the fact. It is how the record already looks. My main repository holds 2,050 commits from five months of building, and 96% of them carry a body — the median body runs about a thousand characters. A fix commit records the symptom as it appeared in production, with the date and the report that surfaced it; the mechanism that caused it; why the existing tests failed to catch it; and the specification that now pins it, written to fail first. Rules are written at the point of change, in the commit that changes it: a deployment file carries wiring and generated secrets, never the owner's settings. Anyone — human or agent — who later asks "why is it like this?" gets an answer from the record, not from my memory.
Why it can't drift far
People ask how I can let agents write most of the code and still trust what ships. The honest answer is that the agent's freedom is squeezed from three sides before it writes a line. The architecture is decided up front, and parts of it are asserted at boot: wire the system wrong and it refuses to start, long before any test runs. Every behavior that matters has a test that is the specification, written to go red before the fix exists. And the benchmarks are built to be able to fail — the test doubles are fault-injected on purpose, because a suite that cannot go red is not a safety net, it is a screensaver.
Inside that frame, what is left for the model to get wrong is mostly local, and local errors are mechanically visible. When an agent improvises in a void, the model decides the quality. When the constraints are given, the system decides the quality — and the model only decides the speed.
So yes, the AI reads the stack trace. The trace is the most structured artifact in the whole loop; refusing to let the best parser read it would be superstition. My job in that loop is not the reading. It is the verdict.
The honest remainder
Two weaknesses are real, and I won't sermonize past them. Sediment is only as good as the habit that writes it — a repository whose log says "fix bug" two thousand times has no memory worth consulting, and most repositories look like that. And history under-records the roads not taken: the rejected design leaves fewer traces than the chosen one, so the record knows what happened better than it knows why the alternatives died. Both flaws are fixable inside the habit — you can write the rejection down, at the point of decision, the same way you write the rule.
Neither flaw is an argument for carrying the model in a head instead. The argument this year was never really about whether machines can write code. It is about where the knowledge lives while they do. I know where mine lives, and it isn't in my skull — it's in the record, written to be read by whoever, or whatever, comes next.