Skip to content
← All posts

Field notes

Spec-driven development is only the start

Spec-driven development decides what to build. Spec-Driven Agents govern how it gets built and prove the outcome.

By Jason ChaffeeFounder, ZeroOverhead.ai · 4 min read

Spec-driven development has won the argument. Write down what you want before an AI agent starts writing code, and you get better results than prompting and hoping. GitHub Spec Kit and OpenSpec have made the practice easy to adopt, and Thoughtworks put it on its Technology Radar. We agree with all of it.

But a spec only answers the first question: what should we build? It leaves the next two open.

  • Did the work actually follow the spec?
  • Can you prove the outcome happened?

And those questions don't stop at launch. Most of a system's cost comes after the first release: one long-standing estimate puts maintenance at about 60% of software's lifecycle cost, and most of that is new features rather than bug fixes. Every one of those changes raises the same two questions again. Writing the spec is where the job starts, not most of it.

Faster code, shakier releases

The pressure on those questions is growing. Agents now write more code than any team can read line by line, and the data so far says speed alone doesn't help. Google's 2024 DORA report, drawn from thousands of engineering professionals, found that as AI adoption rose, delivery stability fell: an estimated 7.2% drop for every 25% increase in adoption.

More code isn't the problem. More code that nobody can show was checked is. The bottleneck has moved from writing software to trusting it.

The industry is starting to describe where this goes as a factory. Warp's Zach Lloyd argues that software engineering is becoming factory engineering: engineers build and tune the system of agents that builds the product. We think he's right, and it is the loop we build on. But a factory is judged by what goes in and what it can prove came out. It should start from a clear intent, prove that the outcome happened, and get better with every run, with people approving each improvement.

That is the gap ZeroOverhead.ai is built for: the software factory that starts from intent, proves the outcome, and improves with every run. Our short version:

Spec-driven development decides what to build. Spec-Driven Agents govern how it gets built and prove the outcome.

A spec you follow, not just a spec you write

In most workflows today, the spec is an input. The agent reads it, does the work, and says it is done. A person reviews the result and hopes nothing important happened in between.

A Spec-Driven Agent treats the spec as the rules of the run. The work moves through defined stages, and leaving each one takes more than the agent's word:

  • checks that pass, named in advance, not chosen after the fact
  • an approval from the right approver where a wrong answer is expensive: a person or a different agent, never the one that did the work
  • a record of what each stage produced, what was checked, and who approved it

An agent never approves its own work. People can pause a run, deny it, or roll it back at any stage.

One change, start to finish

Take a small, ordinary request: add rate limiting to the public API.

  1. Plan. A person states the intent: protect the API from bursts without breaking existing customers. Someone with the authority to approve it does.
  2. Design. The agent writes the spec, with acceptance criteria a check can test: limits per key, the response a client gets when it hits one, and the customers who are exempt. A person approves the spec before any code exists.
  3. Build. The agent writes tests that fail first, then the change that makes them pass. If it weakens a test to get there, that is a finding, not a shortcut.
  4. Test. The change is checked against the whole spec, not only the tests the agent wrote. A failure sends the work back to the stage that caused it, with the reason attached.
  5. Deploy. A person approves the release with the spec, the diff, and the check results in front of them, and the run records what shipped.
  6. Maintain. After release, the system watches the agreed measures. If legitimate customers start getting blocked, that signal opens a new run, with the original spec and its history already attached.

At the end, nobody has to take the agent's word for anything. There is a record of what was asked for, what was built, what was checked, who approved it, and what happened after.

Done means evidence

The critics of spec-driven development have a point: a bad spec just moves ambiguity from chat into Markdown, and a pile of documents nobody reads is not control.

So we define done differently:

Success isn't that an agent ran. It's evidence the outcome occurred, controls held, and a human stayed in control.

Evidence is what turns a spec into something you can trust. It is also what lets the system learn. When something drifts after release, that signal starts the next run, and the spec, the checks, and the lessons learned last time come with it. Those lessons don't rewrite the rules on their own: they are proposed, checked, and approved like any other change. Agents that improve themselves sound good until you ask who approved the improvement.

The rest of the job

Spec-Driven Agents are not a replacement for writing good specs. Deciding what to build is still the hard, human part. They govern everything after the spec is agreed, which is most of the work: building it, checking it, approving it, and every change that follows the first release. They do it with whichever agent SDK, model, and AI coding tool your team already uses.

We will write about each piece here: why an agent should never approve its own work, what counts as evidence, and why agents need knowledge that remembers where it came from.

Govern AI agents without the overhead.

We're working with a small group of early teams. Tell us what you're building.

Get early access