One mind, amplified
In about three months, tlslane went from an empty repository to a from-scratch TLS 1.2/1.3 stack, an eBPF inline data path, a Go control plane, and a continuous multi-region soak fleet — built by one person. The number I keep getting asked about is the pace. It is the least interesting part. The interesting part is that the thing held together, and that Fred Brooks explained why it would, fifty years ago.
Not the speed — the integrity
People reach for a multiplier. Pick one; it doesn't survive contact with the truth. AI didn't type fifty developers' worth of code. What matters isn't how much got written but that what got written is one system: the pipe is a single event→transform core; the same naming convention runs from the lowest record-layer class to the top; the same bottom-up, test-first method built Tls_record before Tls_pipe, every layer trusted before the one above it. That property has a name, and it isn't “productivity.”
What Brooks actually said
In The Mythical Man-Month (1975), Fred Brooks argued that conceptual integrity is the most important consideration in system design — that it is better to have one coherent set of ideas than many good but independent ones. His hard result, “Brooks's Law,” followed: adding people to a late project makes it later. Not because people are bad, but because a design fragments across the minds holding it, and the communication paths between n people grow as n². His prescription was the surgical team: one surgeon who owns the concept, everyone else amplifying that one person's intent rather than negotiating a rival one.
The reflex reading of AI is that it adds developers — a bigger team, so Brooks's Law should bite harder. That reading is backwards.
The assistant, not a second surgeon
An agent with the full context of the project is the surgeon's assistant. It does not hold a competing mental model of the system; it holds yours, and executes against it. There is no second architect to reconcile, no interface committee, no design-by-negotiation seam running down the middle of the codebase. So the n² communication cost that Brooks warned about never appears, because n is still one. What you get is not fifty minds; it is one mind's model, rendered at a speed that used to require many — and therefore used to lose the very integrity that made it worth building. For the first time the coherent-single-vision path and the ship-it-this-quarter path are the same path.
Then I tried to distribute it, and Brooks was right again
Here is the part that convinced me, because it was a failure. tlslane is cross-platform, so I tried the obvious thing: run agents on the Mac and the Windows machines to do the platform work there, natively. It went worse, not better. Context got lost at every boundary. Each machine's agent had a partial picture of the system, and the channel for re-synchronizing those pictures was me, carrying state across by hand. I had rebuilt, in miniature, exactly the thing Brooks warned about — the design fragmenting across holders, the communication tax reappearing — except now the expensive communication link was a human moving context between rooms.
The bottleneck in this way of working is not typing. It is context reconstruction. Every handoff — to another machine, another agent, another session — pays a re-derivation tax and risks conceptual drift. The setup that worked was the opposite of distribution: one agent, one machine, with everything that constitutes the project's memory in one place — the repository, the working notes, the session history, the soak fleet's whole record. The Windows port that actually shipped was driven from that one machine, using CI and remote VMs as a verification substrate, never by an agent stranded on Windows with half the context.
The other half of Brooks
Brooks's other famous essay, “No Silver Bullet,” split software difficulty in two: the essential complexity of the design itself, and the accidental complexity of everything involved in expressing it. He bet no single tool would give an order-of-magnitude gain, because the essential part — deciding what the system is — can't be automated away.
Three months of this didn't refute him; it sharpened the line. The accidental complexity collapsed — boilerplate, the second and third implementation of a parser, the wiring. The essential complexity stayed exactly where he said it lives: in one architect's head, deciding that the pipe takes no local decisions, that session identity comes from TLS content and not a 4-tuple, that a counter split by cause will catch an attribution bug a summed one won't. Those calls were mine. The tool just stopped making me pay the accidental tax to write them down.
So the honest version of the story is not “AI made me fast.” It's that the coherent-vision way of building software — Brooks's ideal, the one that was usually too slow to survive a deadline — is suddenly the affordable one, as long as you keep it one mind and don't fragment the context. That's the discipline behind how everything here gets built, and it's what we bring to a migration.
← All posts