What survives when execution is free

When AI agents can execute any plan in minutes, what separates winning from losing? It's not the code. It's not the speed. It's the spec.

A year ago, I built websites. I'd sketch a design in Figma, handoff to a frontend engineer, wait two weeks, get broken components, iterate three times, and ship. We called it "agile." It was expensive and slow.

Now I describe a website in markdown. An agent reads the spec and produces an initial implementation. That changes the pace of the work, but it does not remove the need to review the code, test the behaviour and revise the result.

This sounds like execution speed has become worthless. It hasn't. What it's done is make execution speed free. The cost moved upstream.

The moment execution became free, three things happened:

First, specs became the constraint. When it costs $50,000 and six weeks to build something, you're willing to live with a mediocre spec. You can't afford to rewrite it. When it costs 20 minutes, you can't afford to get it wrong. You'll rewrite the spec five times if it means the outcome is right. This means specs are no longer a placeholder artifact. Specs are the product.

Second, bad ideas die faster. A bad idea that would have consumed six weeks of engineering time and $50,000 of money dies in the time it takes to write it down and ask an agent to build it. You see the bad idea working in 20 minutes and kill it before it compounds. Good ideas still work. They just get three times more feedback before they ship.

Third, taste becomes the competitive advantage. When two people have similar tools for execution, judgement becomes a greater part of the difference. The person who knows what users need before users do. The person who cuts scope ruthlessly instead of building everything. The person who sees the second-order effects of a feature before they ship it. Taste is pattern recognition. It's seeing what will matter in six months and building for that instead of today.

This is why I obsess over specifications now. Not architecture documents. Not design systems. Specifications. A good spec is: what problem are we solving, who does it solve for, what's the success metric, and what doesn't belong in this version. Everything else is implementation detail that an agent can handle in parallel.

The best engineers I know spend 80% of their time on specs and 20% on code. The mediocre ones spend 20% on specs and 80% on code, arguing about framework choices and optimization that doesn't matter because the spec was wrong.

When execution is free, the tax moves to thinking.

This changes how you build. It changes how you hire. It changes what you compete on. The person who can write a crystal-clear, ruthlessly scoped specification is worth 10 engineers. The person who can execute fast is now commodity.

The irony is that this is ancient wisdom. Donald Knuth wrote this in 1974: "The real problem is that programmers have spent far too much time worrying about efficiency in the wrong places and at the wrong times; premature optimization is the root of all evil." He was right. He just didn't know that the premature optimization would eventually become so cheap that we'd need to invent a new constraint to make work meaningful again.

That constraint is specification.

If you want to stay valuable as a builder in an era where agents execute everything, get obsessed with specs. Learn to kill bad ideas before they're written in code. Learn to scope ruthlessly. Learn to see second-order effects. Learn to write clearly enough that someone (or something) reading your spec for the first time understands exactly what you're trying to build.

That's what survives when execution is free.

I build software for people who run things. If something your business leans on is an old program, a spreadsheet, or a person about to retire, write to me.