Agents made code cheap. Simple, fast, correct software still costs what it always did.

An agent built you a game. It compiles for three platforms. The menus open, the sound system works, the character classes are in place, and a friend can sit down and play it. By every checkbox in the brief it is ninety percent done. Then you watch someone play for twenty minutes. A boss spawn stutters the frame rate for half a second. Two enemies that die in the same tick overwrite each other’s state. The sprite work drifts off-model between scenes. You go to fix the stutter and realize you cannot say whether the handler you are editing is the cause or the third symptom of something underneath. The game is playable. It is not finished. The distance between those two words is what this piece is about.

“Software engineering dies with agents” is a plot from a movie, and repeating it does not make it a forecast. Two things are genuinely true: you can now build software without writing the code by hand, and you can do it without being deeply technical about the code itself. Neither one repeals the constraint that has governed every generation of tooling before this: you can make software cheap, or you can make it simple, fast, and correct, and the second thing has never gotten cheaper. It has only moved. This is an argument about where it moved, and about the harness you build to pay for it on purpose.

Frameworks were always this trade

We have run this experiment before. If you built for the web in the last twenty years, you built on Rails or Django or Express or FastAPI, and the framework handed you an architecture: an ORM, a router, a migration story, a place for everything. You moved fast in the direction the framework pointed, and the speed was real. So was the fine print. The day your Django endpoint needed a query the ORM could not express efficiently, you dropped to raw SQL and went around the abstraction the app was built on. The day you tried to swap Postgres for MySQL, the migration the ORM implied was portable turned into a rewrite. A framework is a bet: give up resolution on the details in exchange for velocity toward the goal, and accept that the wall, when you hit it, is yours to climb by hand.

Nobody called that trade the death of backend engineering. It was priced in. You knew what the abstraction gave you, you knew roughly where it would run out, and the teams that did best were the ones who knew which side of that line their product sat on before they picked the stack.

The same bet, one level up

Agents are the same bet placed at a higher altitude. The framework abstracted the plumbing; the agent abstracts the implementation. And in principle, nothing stops an agent from meeting the same requirements a senior team would meet. Write a pristine, concise specification and spend enough tokens against it, or run sixty generated attempts through an evolutionary filter and keep the best survivor, and there is a theoretical path to software that is simple, fast, and correct. I cannot claim the counterexample is impossible, because it is not. Empirically, though, we are nowhere close, and the rest of this piece is about why the gap persists.

What changes at this altitude is where you stand. You operate at the feature level: add a menu, add a character class, add a skill tree. Each request lands, each demo improves, and each one adds a layer whose interactions with the layers below you have never seen. Past a certain scale you lose the thread, not because the code is hidden but because nothing ever forced you to hold the design while it grew. When a bug appears you can point at it and say fix this, and something changes, and you cannot tell whether you removed the cause or rearranged a symptom. The presentation layer might even be well designed, class by class. The failure is in the seams: the spawned enemies that share global state, the event handlers that were never written for the case where both fire.

The marble statue

A marble statue makes the failure visible. Commission an agent to carve a statue of Zeus, or some Bronze Age god, or a Spartan athlete from the first Olympiad. From the front it is exactly what you asked for: the beard, the musculature, the drape of the cloth. Now walk around it. From the side the proportions wander. From the back the surface is not carved in any style at all, because no viewer was ever standing there when the work was checked. And if you could see inside, you would not find marble. You would find voids, and material only where an observer was expected.

Image generation taught everyone this lesson at a glance, and I would put code generation at a comparable level of maturity today. A reader can tell an AI-written blog post within a paragraph; a user can tell agent-built software within a session. The clunkiness registers the same way slop prose does, before you can articulate why. The glitchy animation, the latency spike, the interaction that almost works: users experience these as one thing, and the name they give it is not “impressive velocity.”

The last five percent is the product

A demo that covers ninety percent of the checkboxes reads as ninety percent done, and this is the accounting error at the center of the 100x story. What is missing is not the last tenth of the features. It is the property that makes the other nine tenths usable: the latency spike that only shows under load, the data race that only fires when two bosses die together, the storyline that stops cohering in act three, the gap between two features that were each generated against a different implicit design. Close that and you have a product. Leave it and you have a half product, which differs from a product the way the statue differs from a sculpture.

Closing that gap is still the process it always was: someone senior enough to care about concurrency, latency, abstraction seams, and consistency of the experience, reviewing with enough context to tell root cause from symptom. Agents now attend every step of that process. They have not deleted a single one.

Your harness is the new framework

So what do you do about it, concretely? What the framework did for you last time: encode the judgment. Only this time nobody ships it as a pip install, because the judgment is yours - which checks are non-negotiable, which failures are cheap, what finished means for your product. That encoding is a harness: the deterministic system around the model that runs the checks, replays the transcripts, gates the merge, and rejects the slop before a human spends attention on it. I have made the longer version of this argument before: the harness is the durable skill, verification is the bottleneck, and you cannot rent the part that knows your definition of good.

The short version: Rails encoded one team’s taste and gave a generation of developers a real multiple on CRUD apps. Your harness encodes your taste, and it is the only place that taste survives contact with a code generator. An agent inside a good harness inherits your definition of done. An agent without one inherits the demo’s definition, which is “looks right from the front.”

Two X is a triumph. Ten is a warning.

Give a senior team an agent inside a good harness and the boring layer disappears: the scripts, the scaffolding, the unit tests, the migrations nobody wanted to write. Call it 2x to production. That number deserves celebration, because it is enormous, and it is stable, because the human is still doing the one thing humans remain the constraint on: making decisions. The number of good decisions a person can make in a day did not go up this year. Decision-making is trainable, but it is not yet abundant, and no token budget substitutes for it.

Push past that and the curve turns over. At 10x, the review capacity that made 2x safe is saturated. At 50x, nobody in the building can say what the system does. At 100x, you are generating statues. Output volume keeps climbing; finished software does not.

This is why “we automated the boring stuff and ship twice as fast” is the strongest claim I am willing to make, and also the only one I need. It is already a generational improvement. Attempts to push it to 50x or 100x with the current state of the tools do not produce fifty times the software. They produce collapse into slop, plus a demo reel.

So no, the industry does not die. It re-prices. The typing was never the expensive part, and the part that was expensive - deciding, verifying, finishing - costs today what it cost five years ago. The teams that internalize this are building harnesses and banking a real 2x. The teams that do not are shipping half products at 100x and filing the user frustration under rollout problems.