Software is no longer built the way it used to be. And it never will be again.

I. What changed

For fifty years, code was scarce and expensive. One human wrote it, another reviewed it, a third planned it, and a company's speed was limited by how many of those humans it could hire and coordinate. Between 2023 and 2026 that constraint disappeared.

First came the assistant: intelligent autocomplete that most developers adopted in months. Then the copilot, which wrote complete functions and doubled writing speed without touching review speed. And in 2025 came the agent: systems that run entire tasks, open Pull Requests, and work for hours. Code multiplied by eight, by ten. Cost per token fell by half each year. And the developer stopped writing and started directing.

Today a developer directs agents that write more code than they could write in a month. They use three providers at once. They switch models when credits run out. And every provider builds its own cage.

GitHub reported that Copilot generates 46% of its users' code — nearly half. GitHub, Feb. 2023. It remains the most cited public reference heading into 2025.

II. The bottleneck moved

When writing was expensive, the limit was production. Now that writing is nearly free, the limit sits in three new places:

• Specify. Know what was actually asked for, with verifiable criteria, before an agent starts working from an ambiguous sentence.
• Coordinate. Approve, reject, and direct what dozens of agents from different providers do without losing hours jumping between terminals or approving blindly.
• Verify. Confirm that what was produced does what it should, fits the rest of the system, is well built, and is secure — before it reaches production.

Existing tools cover fragments. Task tools live disconnected from the code. Review tools comment but don't decide. Each provider's orchestrators only govern their own agent. No one governs the full cycle, because whoever sells the agent cannot be its judge, and whoever sells the model will not neutrally orchestrate a competitor's.

III. The discipline that emerges: specification-guided development

Teams that work best with agents converged on the same methodology, under names like OpenSpec or Spec-Driven Development: the specification leads, the agent executes, and verification closes the loop against the specification. It is not bureaucracy; it is the only way to use agents at scale without code becoming uncontrollable.

The practical problem is that nobody writes specs. So the spec has to be extracted — from the ticket, from the tests, from the repository's own context, from the instruction that generated the code — and inferred when it does not exist, so the human only confirms or corrects. And it has to exist in two versions: one a Scrum Master can read and one an agent can execute.

IV. What has to exist

A team that builds with agents needs, end to end, five things connected by the same context:

And one condition that runs through all five: neutrality. The layer that governs cannot write code or favor a provider. Whoever decides does not compete in the game.

V. What comes next

Fleets: one developer will supervise dozens of agents, and agents will outnumber humans on every team. Model commoditization: margin migrates to orchestration, context, and data. Regulation: Europe, North America, and Latin America will require knowing what percentage of code an AI generated, with which model, who reviewed it, and with what evidence. And the budget shift: development AI will stop being bought from productivity budgets and start being bought from risk and compliance budgets.

Each of those trends makes the layer that governs the full cycle more necessary. We built it because we needed it to survive our own volume of code. Today it belongs to any team that wants to build with agents without losing control.

From idea to merge, governed.