I had an agent knock out a feature this morning that would have cost me a day in 2022. The tokens cost less than my coffee. Then I spent the rest of the day in calls about what to build next.
That is the story. The cheap part got cheaper. The expensive part didn’t.
The work was never the typing
Brooks said this in 1975. Weinberg said it in 1971. Software is the residue of a group of humans arguing about what the system should do. The argument is the work. The code is the byproduct.
We spent fifty years optimizing the byproduct. Faster languages, better editors, type systems, package managers, Stack Overflow, autocomplete. Each one shaved a slice off the typing. Now agents have shaved off most of what was left. What you see underneath is what was always there: people trying to agree.
You can’t autocomplete an argument.
When code is free, the spec is the limit
When typing was the bottleneck, engineers were the choke point. Standups, sprint planning, “what’s blocking you” — all of it pointed downstream. Now the choke point moves upstream. Agents will happily implement whatever you tell them. They will implement the wrong thing just as fast as the right thing.
So the question becomes: who writes the spec, and how good is it?
This is uncomfortable because most product organizations weren’t built for this. PMs wrote tickets that were good enough for a human engineer who would push back, ask questions, and quietly fix what didn’t quite parse. Agents don’t push back the same way. They produce a plausible answer to whatever you actually wrote down — which is usually not what you meant.
The new bottleneck has a job title, and it isn’t “engineer.”
Cheap things get overproduced
Economists have a name for this: Jevons paradox. Make coal more efficient and you burn more coal, not less. Make code cheap and you ship more code, not less. None of it is necessarily code anyone needed.
A product with twelve features is usually eleven features away from being good. Jobs cut Apple’s lineup by something like seventy percent in 1997 and that’s the move that saved the company. Subtraction. He had a line about it: focus is saying no. That was hard when shipping a feature took a quarter. It is harder now that it takes an afternoon.
Saying yes used to require commitment. Now it requires a prompt.
Agents can’t do osmosis
A senior engineer answers a design question in thirty seconds not because they’re smart but because they were in the room when we decided not to do that. They saw the outage. They watched a customer scream at a sales rep. They had the hallway conversation. None of it is in the code. None of it is in the wiki. Most of it isn’t written down anywhere.
Agents only see what you put in the prompt. Whatever is implicit, whatever sits in someone’s head, whatever lives in a half-remembered Slack thread from 2024 — invisible. The agent will be confident anyway. It will produce a clean, plausible answer to a slightly wrong question. That is the failure mode.
When an agent gets something right at our shop, the honest version is: we did the context work. The model just typed.
Write the why down. Or build agents that do.
Polanyi said we know more than we can tell. He’s right. We also tell a lot less than we know, because writing it down is boring and there’s a deploy to ship.
The interesting move is using agents on the other end of the loop. Point them at the diff history, the issue tracker, the chat archive, the design docs nobody reread. Let them mine out the patterns and the decisions and the why-we-stopped-doing-it-that-way. The output won’t be perfect. It will be better than the void you have now.
You end up with a written substrate the org would never have produced on its own. That is worth something.
The moat is the org chart
Every previous productivity tool — version control, CI, IDEs, microservices, containers — turned out to be a multiplier. Coherent teams got more coherent. Dysfunctional teams got more dysfunctional, faster, with better tooling. The tool didn’t fix the org. It cranked up the volume on whatever was already there.
Agents are going to be the loudest amplifier yet. Teams that already share a clear picture of what they are building will ship absurd amounts of stuff. Teams that don’t will ship absurd amounts of the wrong stuff, much of it broken in ways nobody will catch until later.
The companies that come out ahead won’t be the ones with the best models. The models commoditize. They will be the ones whose fifty people can stay aligned on a shrinking set of decisions while output per head goes up. That’s culture. That’s writing. That’s management. It always was.
So what
The pitch was: agents make engineers faster. That’s true and not very interesting. The interesting question is whether they can make organizations faster, which is a different problem with the same word in front of it.
Cheap code does not produce good software on its own. It never did. What it does is expose, with much higher resolution than before, whether your team actually agrees on what it is building. If you do, the leverage is real. If you don’t, you now have a very fast way to be wrong.
Pick which one you’re optimizing for. The agents will do the rest.
References: Fred Brooks, The Mythical Man-Month (1975). Gerald Weinberg, The Psychology of Computer Programming (1971). Steve Jobs, WWDC 1997 Q&A. Michael Polanyi, The Tacit Dimension (1966).
