The one-mind thesis
An earlier post told the story: a from-scratch TLS stack built solo in three months, and Fred Brooks — fifty years early — explaining the part that actually matters, that it held together. Since then the question I keep getting is different: if the answer is “one mind, amplified,” why do AI coding tools built on comparable models feel generations apart? I think the thesis, stated plainly, answers that — and makes a prediction you can bet against.
The thesis
A system keeps its conceptual integrity only while exactly one mind holds write authority over its design. Every tool for building software with AI either preserves that condition or breaks it — and that, more than the model inside, decides how the tool feels to use.
“Write authority” is the precise phrase, and the rest of this post is about why the precision matters.
Three shapes of harness
Strip the branding off the current tools and there are three architectures.
The inline assistant puts a second mind inside your editor, interleaved at keystroke granularity. You are mid-thought; it injects a completion drawn from a shallower view of the system; you accept or reject and resume thinking. Every acceptance is a micro-handoff of design intent through the narrowest channel that exists — a few tokens of local context, no history, no verification. The assistant acts inside your loop but never holds the whole design and never runs the tests. Brooks's n has quietly become two, and the two minds are reconciled hundreds of times an hour, at the finest possible grain, by you.
The orchestra goes the other way: a planner agent decomposes the task, executor agents implement the pieces, a critic agent reviews the result. This looks like an org chart because it is one — and the artifact mirrors it, exactly as Conway's law says it must. Where the planner's model of the problem and an executor's model disagree, the code has a seam. No single participant — including you — holds the whole design, so nobody notices the seam until it fails. This is design-by-committee running at machine speed: two architects, or five, where the thesis permits one.
The agent that owns the loop holds the full context of the project — the repository, the conventions, the history of decisions — and acts end to end: reads, edits, builds, runs the tests, observes the failure, revises. You hand off intent at coarse boundaries: a task goes in, a verified diff comes out. Design authority never fragments, because within the task the agent executes your model of the system, and between tasks the only mind making design decisions is yours. n stays one where it counts.
Three months of building tlslane this way — and one failed experiment in distributing the work — taught me the differences between these shapes are not ergonomics. They are Brooks's communication cost, either paid or not paid.
What exactly must be singular
Here is the refinement that took me longest to see: the thing that must be singular is write authority, not cognition.
Many minds are fine — as readers. Fan a dozen agents out to search a codebase, review a diff from adversarial angles, verify a claimed bug independently: this works, and I use it daily. It works because a reader's output is a conclusion, and conclusions compress into a report without loss. Design intent does not compress. It lives in a thousand small commitments — that the pipe makes no local decisions, that session identity comes from TLS content and never a 4-tuple — and every attempt to hand that bundle to another deciding mind loses part of it in transit.
That is why Brooks's surgical team has one surgeon and many assistants, not three surgeons and one patient. The assistants extend the surgeon's reach; they do not share the knife.
The falsifiable form
Comparing products confounds the harness with the model inside it, so a fair version of the thesis has to be a prediction, not a review:
Harnesses that interleave two minds at fine granularity, or split write authority across agents, will cap out — and stay capped as models improve — because their losses are architectural, not cognitive. Harnesses that keep one mind owning the loop will scale with model capability.
If the next generation of models makes inline completion feel like an architect, or makes planner/executor committees produce seamless designs, the thesis is wrong. My bet is the opposite: better models will make the architectural losses more visible, because the model will less and less be the bottleneck. The corollary for teams is uncomfortable but I believe it: the unit of AI leverage is not the organization. It is the individual mind with an amplifier — and adding agents to a project recreates Brooks's law unless every one of them writes under a single authority.
The missing half: the channel
One question remains, and it completes the theory. Why can design intent be handed to an agent at all, when handing it to another human is so lossy that Brooks built a law out of the loss?
Because a large language model is, by its nature, a translator between representations of thought — human language, machine language, and the compressed half-formed gesture in between. Brooks's n² was never really a headcount cost; it was a channel cost. Narrow channels between minds destroy design intent, so the only safe place for a design was inside one head, and one head could only type so fast. The agent does not add an n to that equation. It widens the channel of the one existing mind — from keystroke-rate to something close to lossless — so that, for the first time, intent survives the handoff.
So the thesis has two clauses, and needs both. One write authority, so the design never fragments. One lossless channel, so holding the authority no longer means doing all the rendering yourself. Conceptual integrity plus a wide channel — Brooks's ideal, finally at an affordable price. That's the discipline behind everything built here, and it's what we bring to a migration.
← All posts