AI is changing the economics of software delivery. The question is no longer whether teams should iterate. It is whether their workflows still match the bottlenecks they were designed to solve.  

By Harmen Hilvers, Consultant at ALTEN  

For a long time, Agile was the right answer to how software got built.  It offered teams a way to move away from heavy upfront planning, shorten feedback loops, and adjust course as they learned. That mattered because implementation was expensive, iteration was slow, and the cost of heading in the wrong direction often stayed hidden until late in the process.  

That backdrop is starting to change. AI is making execution cheaper and faster than most organisations are changing the way they plan, review, and coordinate work. That does not mean Agile has stopped being useful. It means many Agile workflows are still tuned for a set of constraints that are weakening. 

Agile was built for scarce execution

Most Agile practices were shaped around one central constraint: human implementation capacity.  Writing code took time. Testing took time. Refactoring took time. Coordinating handoffs across functions took time. Because execution was expensive, teams needed a way to reduce waste and avoid building the wrong thing for too long.  

That is what Agile was built to handle. It broke work into smaller increments, made feedback faster, reduced the cost of changing direction, and accepted a simple truth: teams rarely know the right answer upfront.  

That logic still holds. What is changing is the economics underneath it.  

AI changes the cost structure 

With modern AI systems, first-pass implementation is often much cheaper than it used to be. Code generation is faster. Exploring solution variants is faster. Producing a rough MVP is faster. Even documentation, scaffolding, and test generation can be accelerated.  

As a result, the constraint shifts.  

The hardest part is no longer always producing software. Increasingly, the harder part is deciding what should be produced, making the context explicit enough to produce it well, and preserving coherence as the system evolves.  

Execution is becoming more abundant. Clarity is not.

That single shift changes where organisations should invest their time.  

The new bottleneck is coherence 

When execution speeds up, weak thinking becomes more expensive. If specifications are vague, AI can produce the wrong thing faster. If architecture is unclear, teams can generate inconsistency at scale. If interfaces are unstable, speed amplifies rework. If nobody owns the intent, fast implementation just creates fast confusion. That is the real shift. The bottleneck is moving away from code production and toward requirements quality, architectural coherence, interface definition, review quality, and decision-making discipline. That does not reduce the importance of software engineering. It raises the standard for it.  

Iteration still matters, but at a different level 

One common misunderstanding in AI discussions is that faster implementation means teams can finally replace iteration with perfect upfront planning.  

That is not realistic.  

Customers still refine their understanding when they see working software. Teams still learn by observing real behaviour. Product decisions still improve through feedback. 

Iteration remains essential. But the center of gravity shifts upward.  

Instead of repeatedly patching an unstable implementation, teams can increasingly iterate on intent, specifications, acceptance criteria, contracts, constraints, and product decisions. The goal is no longer just to ship smaller chunks faster. It is to make the system easier to adapt, regenerate, and verify as understanding improves.  

Code becomes less sacred  

A useful way to think about AI-enabled delivery is this: code is becoming less sacred, while specifications, interfaces, and decision records become more valuable.  

That does not mean production code is disposable in any simplistic sense. Real systems still carry operational history, integration complexity, security requirements, and performance constraints.  

But it does mean companies should stop treating code as the primary store of product intent. In an AI-enabled workflow, the system of record shifts toward clear specs, explicit contracts, architectural boundaries, documented decisions, and validated constraints.  

The stronger those are, the less expensive the implementation becomes.  

Collaboration changes shape  

Traditional Agile puts significant weight on human synchronisation: standups, sprint planning, backlog grooming, reviews, retrospectives. Those practices emerged for a reason. When humans are doing most of the implementation, frequent coordination is necessary.  

AI changes that balance. The value of collaboration shifts away from low-information status exchange and toward higher-value alignment: what problem are we solving, what constraints matter, what must remain stable, and what good actually looks like.  

The result is not less collaboration. It is different collaboration. Teams spend less time coordinating labour and more time coordinating truth.  

What companies should rethink  

Backlogs

Breaking work into smaller tickets is still useful. But the main value is no longer simply fitting work into human capacity. The greater value is making intent clear enough that fast execution does not create ambiguity.  

Reviews

When implementation becomes cheaper, review should spend less time admiring volume and more time testing consistency. Does this fit the architecture? Does it preserve product intent? Does it create operational risk? Does it align with defined interfaces?  

Architecture

AI can increase delivery speed locally while degrading system quality globally. The faster teams can generate change, the more valuable strong boundaries and clear contracts become.  

Requirements

If execution cost drops, the return on good requirements rises sharply. Companies that treat requirements as a lightweight admin task will underperform organisations that treat them as a core design discipline.  

Cadence

If implementation compresses, planning and review structures built around older delivery speeds may no longer fit. Teams should examine whether their ceremonies are still serving learning and governance, or simply preserving habit.  

What should stay?

None of this is an argument against Agile principles. The most important Agile ideas remain sound: feedback matters, learning matters, small increments reduce risk, transparency matters, and adaptability matters. What changes is the operating model around them. AI does not remove uncertainty. It changes the cost of acting under uncertainty. That means organisations should preserve the spirit of Agile while redesigning the mechanics.  

The better question

The question is not whether Agile survives AI. The better question is whether companies are willing to redesign their workflows for a world in which humans define intent and constraints, machines accelerate execution and exploration, and coherence matters more than raw output. When code is no longer the dominant bottleneck, the process should stop pretending that it is. The companies that adapt fastest will not be the ones that simply generate the most software. They will be the ones who build the strongest systems for clarity, alignment, and architectural trust.