The Loop Moved

The Agile Manifesto turned twenty-five this year, and the anniversary arrived the way these things do — with a round of essays asking whether it survives the age of AI. Most treat it as a methodology on trial: do the stand-ups still make sense, is the sprint the right unit, has the burndown chart met its match. Wrong court. The manifesto was never a methodology. The twelve principles were the implementation. The thing underneath them was a single idea, and it is the only part worth carrying forward.

Strip away the practices and what the seventeen signatories were reacting against in 2001 was one condition: the gap between deciding something and finding out whether you were right had grown too long to survive. Waterfall’s sin was never sequence. It was that feedback arrived after it was too expensive to act on — so people defended plans instead of changing them, because by the time reality spoke, changing was ruinous. Every principle is a different lever on the same intent: short cycles, working software over documentation, welcoming late change, the retrospective. All of them exist to shorten the distance between intention and reality so you can be wrong cheaply.

Hold onto that phrasing, because it is the whole argument. Not “ship faster.” Not “be flexible.” Make being wrong cheap. Speed and flexibility were only ever the means.

Agile compressed a build loop

In 2001 the expensive, slow loop ran build, then ship, then learn. You committed to a design, spent months constructing it, and only discovered at the end whether the thing you built was the thing anyone needed. The cost of being wrong sat almost entirely in construction — code was slow and expensive to produce, so producing the wrong code was the disaster you organized your whole method to avoid.

Agile attacked exactly there. It cut the loop from years to weeks and forced reality to speak early — a working increment every fortnight, shown to the people who own the outcome, so being wrong cost a sprint instead of a fiscal year. It worked so well that a generation came to believe the ceremonies were the point, and ran the stand-ups while quietly reverting to waterfall underneath — which is its own essay. But the intent held: put the moment of learning as close as possible to the moment of deciding.

AI collapsed the build loop to near zero

The thing agile spent twenty-five years compressing — the cost of producing working software — has now fallen through the floor on its own. An agent generates a plausible working feature in an afternoon. It drafts the migration, writes the integration, produces the code that used to be the expensive part. The build-and-ship half of the loop, the half the whole method was built to shorten, is approaching free.

The naive reading is that agile is therefore finished. That reading mistakes the lever for the intent. If the goal was only to shorten the build loop, then yes, we are done. But the goal was to make being wrong cheap, and being wrong is a property of the whole loop, not of the build step alone. When you make one segment free, you do not eliminate the cost of being wrong. You relocate it.

Here is the shape of it. When code was expensive, the specification was cheap by comparison — a paragraph of intent, a few days of construction, and the construction dominated the risk. Reverse the economics and you reverse the risk. When construction is free, the specification becomes the expensive decision, because it is now the only place a mistake is still costly. And a second cost appears where there was none before: the judgment that what the agent produced is actually what you meant. When a human wrote every line, drift was caught in the writing. When an agent writes it, you can generate a month of confident, working, plausible output and never once find yourself in any of it — and never know, until you stop and read it back.

So point the arrow where the cost went

This is what it means to carry the manifesto’s intent into the AI era rather than its principles. The question was never “do the ceremonies still apply.” The question the intent forces is: where is the loop still long, and how do I make being wrong there cheap again? In 2001 the answer was the codebase, and agile answered it. Now the answer is the specification and the judgment — and almost nobody has built a loop around those yet.

What would it even mean to make being wrong cheap about a specification? To get feedback on what you asked for in hours instead of discovering after a month of generated output that the ask was subtly off? To make taste and judgment iterable the way agile made code iterable? That is the frontier the intent points at. Not a new set of ceremonies — a loop wrapped around the part of the work now most expensive to get wrong: the human’s judgment about what the agents should be doing at all. That judgment is a matter of bound authority, not specified capability — the companion to this argument.

The retrospective, of all twelve principles, is the one that survives fully intact — and it is not a coincidence. It was always the meta-principle, the one loop whose only job was to inspect and correct the others. In a workflow where agents build and a human ushers, checks, redirects and signs off, that inspection stops being a scheduled ceremony and becomes the primary activity. The human moves from in the work to beside it — one level up, exactly where the cost moved. This is the seam again, drawn now through the delivery method itself.

Now put it somewhere it can't be wrong

Everything so far is general, and generality is where arguments go to sound true without being tested. So take the claim to the hardest ground I know: a regulated enterprise core. Four decades of accreted business logic. Releases where a mistake reaches the general ledger, the auditor, and occasionally the regulator. Change historically measured in quarters, because the cost of being wrong is measured in something worse than a slipped date.

This is the purest case of the problem agile was invented to attack — the loop between deciding and finding out is as long and as expensive here as it gets anywhere in enterprise software. And the same collapse is arriving: agents can now generate the code, draft the migration, produce the integration on a mission-critical core in an afternoon. The cost is relocating here too, upstream, onto specification and judgment. But on this ground the stakes invert from the startup’s. When output is cheap and the core is unforgiving, cheap-and-wrong is not merely inefficient. It is dangerous. “It demoed fine” is not a standard on a system where wrong reaches the ledger. The cheap output has to be caught — and catching it is a human act of judgment against decades of context no agent holds.

This resolves a contradiction that sounds fatal until you follow the intent through it: how does a shop claim to deliver AI-native and insist a human signs off on everything, in the same breath? The answer is that these are not the same workflow. Generation goes native — agents run it end to end, because that is where the cost fell out. The gate stays human, end to end, on purpose — because that is where the cost moved to, and on a regulated core that cost is measured in consequences. The human is not in the gate because the tools are not good enough yet. The human is in the gate because that is where being wrong is now most expensive. This is not abstract — it is how a Pegasus4i engagement actually runs.

The manifesto pointed the arrow

So agile does not transform into a new methodology, and it does not die. It does something more useful than either: it tells you where to look. The intent — make being wrong cheap — is a compass, and a compass does not expire when the terrain changes. It points at the new high ground. The principles compensating for the cost of building software get quietly obsoleted by cheap generation. The principles about human trust and self-organizing teams narrow to the workflows that stay human end to end. And the one principle about reflection becomes the main event, because inspection is now the scarce and expensive act.

There is a version of this future that assumes the human at the gate is real oversight and not a rubber stamp. Where that holds, everything above follows. Where it fails — where fidelity slips and the reviewer cannot see the error — the manifesto’s oldest instinct comes roaring back with more force than ever: working, tested software over a description of it. Which of those two worlds you are standing in is not a company-wide fact. It is a per-workflow question, decided one loop at a time. That, too, is in the intent. It raises the question the companion essay takes up: if the human gate is where the cost went, what happens to that gate as the guardrails earn trust — because it does not hold forever, and it was never meant to.