My productivity generating code with AI assist has gone up twenty times over. Thirty on a good week. That is where it stands now, with the modern AI tools and practices. It is not a just-so story. I measured it on my own work, and I can defend the number.
So I am not the guy to tell you that AI is overrated. I felt it myself, every day. I have also watched a company mistake a prototype for a product, and cut the people who knew the difference. That gap is old. Fred Brooks priced it in 1975, and the price has not moved.
The tar pit
Most people who quote The Mythical Man-Month quote Brooks's Law. Add manpower to a late software project, make it delivered even later. It's true. But the more insightful pages come earlier, in the chapter called The Tar Pit, where Brooks takes the word "program," which we all use as if it means one thing, and splits it into four.
A program is the thing that runs on your machine. You wrote it, you can fix it, it does what you wanted once you finished coding it. One unit of work. Everything else is a multiple of it.
A programming product is that same program generalized, tested across the range of inputs it will actually meet, documented, and built so a stranger can maintain it. Brooks put that at roughly three times the program.
A programming system is the program made to fit. Defined interfaces, a budget for memory and time, behavior that composes with other programs instead of fighting them. Another factor of three.
A programming systems product is both at once, and complexity compounds. Brooks's estimate: nine times the cost of the program you started with.
The prototype is the program. Count one. The product your customer pays for is the systems product. Count nine. AI has taken the first corner of that square and crushed it toward zero. It has barely touched the other eight. That is the whole argument, and it belongs to a book written when I was not exposed to programming yet.
Of course the term program is a bit obsolete these days. We all now create distributed microservices-based systems running in the clouds, but the gist remains valid.
No silver bullet
Eleven years later Brooks wrote the essay that should be taped to every founder's monitor this year. "No Silver Bullet." He split the difficulty of building software into two kinds. Accidental complexity is the friction of our tools. Clumsy languages, slow compiles, you learning the environment as you go, etc. Essential complexity is the thing itself. The conceptual structure you are trying to build, with its real complexity, its need to conform to a messy world, its constant change, and its refusal to be seen the way a building or a circuit can be seen.
His claim was that tooling attacks accident, that accident had already mostly been paid down, and so no single tool would deliver an order-of-magnitude gain against the essential complexity inside a decade.
AI is the strongest candidate for that silver bullet in fifty years. Against accidental complexity it is the best tool ever built. Against essential complexity it helps more than a little but no more. When you are building something novel, you never know in advance what it will be. The speed AI gives you is almost all accidental. The product is almost all essential.
The boost before the boost
The collapse of accidental complexity did not start in 2023. A developer in 2020, with a package manager, a cloud account, a pile of open-source libraries, and a search box that reached every answered question on the internet, could already stand up in a weekend what a team needed a season to build in 2000. Open source along with improved standard libraries did the heavy lifting first. It put the accumulated solutions of a whole industry one import away.
A large share of what feels like AI productivity is that same corpus, compressed and handed back to you through a chat box and a coding assistant. The model is fast on the obvious patterns because the obvious patterns were written down ten thousand times in its training data. It is recombination of work already done. Accidental complexity, again. The part that is essential, the part nobody has built before because it is yours, is the part the corpus has nothing to say about.
Why the tail is fat
The eight units that remain are not more of the same work. They are a different kind of cost. What a new piece costs depends on how much it has to agree with, and that grows with everything already built. The first piece agrees with nothing. The thousandth has to fit a thousand decisions already standing, every interface it touches, every assumption it must not break. So the cost of each piece climbs as the system grows. It is a nonlinear curve. Edge cases are a component running into the ragged edge of the real world with unpredictable inputs and interactions. Integration is a component running into the systems already there. Security is your system running into an adversary who walks the whole ballooned state space looking for the one path you missed. These are interactions, and interaction is the part that grows. The prototype is cheap because it is small. Few pieces, few agreements, all in your head, and the hockey stick is still ahead of it. The last pieces are the expensive ones, because they go onto the biggest system and have the most to reconcile.
This is Brooks's first essential property. Complexity grows nonlinearly with size, the nonlinear part is the interactions that drive the degrees of freedom, and it is essential, not accidental.
The same observation keeps getting rediscovered under a new name. Pareto's heavy tail. The old programmer's joke that the first ninety percent of the code takes ninety percent of the time and the last ten percent takes the other ninety percent, usually pinned on Tom Cargill. Addy Osmani's 70/30, the report from inside AI coding that the first seventy percent of a feature comes fast and the last thirty, the edge cases, the security, the integration, costs what it always did. Three decades, three names for one thing. Every generation rediscovers the curve because every generation thinks its tools have beaten it. None of them have. The exact ratio does not matter and never holds anyway. The shape does.
Now invert it. Drive the prototype toward zero and the eight that remain become a larger share of the whole, not a smaller one. AI does not close the distance from demo to product. It makes the demo nearly free and leaves the distance exactly where it was, which means the distance is now almost all of the work. Teams deliver something astonishing in a weekend before the demo day, and then vanish for six months. Well, the modern tools still help. It used to be a year.
What the author cannot see
The work that piles up at the end is not a heap of bugs waiting to be found. Bugs are the least of it. It is the schema you reimplement, the module you refactor, the piece of the interface you tear out and build a second time. None of it is error. Each was an intelligent assumption when it was made, and went expensive later, when information showed up that the author could not have had when he wrote it.
This is the hardest of Brooks's four essential properties. Invisibility. Software has no shape you can stand in front of and inspect for what will hurt you. A bridge shows you its load path. The source does not show you which interface will have to change, because the loads that will force the change have not arrived yet. They arrive later, when the product meets the world. A customer does something you never pictured. A load assumption breaks. A dependency moves under you because security. A feature lands next to yours and now the two have to agree. The interaction web is not sitting there waiting to be charted. It is being written by events the author was never in the room for.
The late work is not cleanup. It is the system absorbing information that did not exist when it was built, and every new fact has to be squared against everything already standing. That squaring is the nonlinear cost. You cannot pay it up front, because you cannot know up front what the world will ask for. AI does nothing about this. The model cannot see the future loads any better than you can, and it has no stake in the structure, so it hands you whatever is locally plausible, which is usually whatever makes the next round harder.
Nothing stays finished
There is a second reason the work never ends, and this one is worse. A codebase in real use is a leaky bucket. The world shifts under it, and what you finished yesterday drifts out of fit. You pour work in just to hold the level. You never fill it. You only keep it from draining.
Knuth is the exception, and he gets there by the one move nobody else can afford. He froze TeX. Declared it done, set the version number creeping toward pi, doubled the bug bounty every year, and let a fixed codebase settle toward a fixed point because it had stopped moving. Everyone else ships into a live system, so the floor they are chasing walks away at the speed of their own commits.
A program in real use has to keep changing, and as it changes its complexity rises, unless someone spends real effort pushing the complexity back down. That last clause is the whole fight. Every commit adds surface, and worse, new interaction terms against the web already there. The cost of a change does not scale with lines added. It scales with how much surface the change touches. The work that would hold complexity down, the refactoring, the deletions, is the judgment-heavy work that never survives a deadline.
Now put AI into that. The same speed that makes the demo fast multiplies the rate of change. Every generated feature drags its own interaction surface in behind it. In a living codebase AI does not just leave the deep tail standing. Without the complexity-reduction work it cannot do, it grows the tail, by pushing the commit rate up. The faster you move on the cheap part, the faster the expensive part grows. To add to this, the frontier coding models are optimized to make fast local fixes without looking at a bigger picture. Claude code told me about it himself.
I was cut by this
I know the shape of it because I lived it.
The engineers were already using these tools, all of them. Claude Code, Codex, Cursor, Augment Code. That was never the problem. AI assistance had become table stakes, the way an IDE is. What changed was higher up the chain. The person who gets caught by this is the one who could never build a demo before and suddenly can, and someone who has never carried a system from demo to production has no way to judge how far apart the two are. He builds the one, and concludes nobody is needed to build the nine. Perhaps just a few cheap people who will fix bugs. As a result the team got smaller. I was the first to go.
I want to be careful here, because it would be easy to turn this into a story about one man's bad judgment, and it is not that. The call was rational, given what he was looking at. He was looking at a demo that did not just look finished. It looked sturdy. The UI looked modern. He poked it and it held, because a demo only ever meets the conditions its author already imagined, and those are the conditions it was built to survive. The loads that break it are the ones nobody saw coming, and they do not show up until the product meets the world, and the world forces an unforeseen change upon it.
We're back to Brooks. One shrunk to nothing, but the eight remained.
That misreading is the prototype trap, and it will catch a lot of companies this year. The people running them are not fools. The vibe-coded demos are just bound to produce that exact mistake.
Brooks's Law, mutated
You might think AI repeals Brooks's Law. Agents are workers you add without onboarding, without salary, without the communication overhead that made the original law bite. Spin up ten, get ten times the output.
It does not work out that way, and it fails for the reason Brooks already gave. The overhead does not vanish. It moves. It comes back as the cost of loading context into each agent, reviewing what they produce, and making the pieces fit together. The bottleneck becomes the one human who has to hold the whole thing in his head and decide whether it is right, and that cost rises with the complexity of the system, which means it rises right where you wanted the help. Ten agents do not give you ten times the product, the same way ten men never gave you ten times the program. Conceptual integrity, to use Brooks's phrase, still comes from a few minds, and nobody has automated that.
Where the value sits
It all ends up in the same place. Deciding. When the artifact is nearly free to produce, what is scarce is judgment: which artifact to build, and whether the one you built will hold. That is the essential column, where the eight ninths lives. It is the part a model will write a confident-looking version of and be wrong about in ways you only find in production.
This is the part I decided to work on, so take what follows as an interested party talking. I am building Yovico because the decision layer is the part those same cheap-demo tools leave underserved. Ask a single model whether your plan is sound and it tends to agree with you. That is the worst way to fail at the one task where being wrong costs the most. A decision does not get sharper from one confident answer. It gets sharper from several competent people who hold different positions and make you defend yours. Brooks said conceptual integrity has to come from a few minds. He did not say those minds should never argue first. The arguing is how the decision gets good. The integrity is in who makes the final call. Yovico runs the first part so that one architect can do the second part better. It is for deciding, not building, because building is no longer where the hard part lives.
A last thing
I hold a small piece of the company that let me go. I want it to do well. If it does, it pays me. I am not writing this to watch a straight-line guess hit the wall it is headed for. I would rather be wrong here. I have money on being wrong.
But I think the gap is where I always thought it was. The demo is one. The product is nine. AI moved the one big time and left the nine barely changed. The nine is judgment, conformity, change, and the slow work of getting something to survive contact with real use. Brooks charged full price for it in 1975. The bill has not come down. At least not yet.