A task that would have filled a two week sprint not long ago can now be finished in a day. It does not take a heroic effort or a late night. An engineer describes what is needed, an AI coding assistant writes most of it, and the rest of the day goes on reviewing, testing and fixing the parts the assistant got wrong.
This is no longer unusual. It is becoming the normal week for teams that use these tools well, and it raises an awkward question for anyone who runs software projects. If the work inside a sprint now takes a day, what is the sprint for? My answer is that Agile, as most teams practise it today, is dead. Not the ideas behind it, but the machinery we built on top of them. In this article I want to explain why, what AI has really changed, what the outcomes of using it look like in practice, and where I think this leads, including a question I keep coming back to: are we heading into an era of fixed cost projects?
Why the sprint existed
The two week sprint was never magic. It was a compromise. Teams needed a cycle short enough to get feedback often, and long enough to build something worth showing. Writing code by hand took time, so two weeks was roughly the smallest unit in which a team could design, build, test and demonstrate a meaningful piece of work.
Everything else in the Scrum toolkit grew from that assumption. Estimation and story points existed because effort was large and uncertain, and we needed a way to guess how much would fit into a sprint. Sprint planning existed because committing to two weeks of work needed a meeting. Velocity and burndown charts existed because we needed to track progress across many days of typing. The sprint review existed because there was finally something to show at the end. Take away the assumption that code is slow to write, and the whole structure starts to wobble.
What AI has actually changed
It is worth being precise here, because the hype makes it easy to overstate. AI coding tools are very good at the parts of the job that used to eat the most hours: boilerplate, scaffolding, CRUD screens and API glue, translating a clear description into working code, writing tests, migrations and documentation, refactoring and upgrading old code, and explaining an unfamiliar codebase. With agent style tools, an engineer can now hand over a whole task, review the result and move on to the next one, sometimes running several in parallel.
What AI has not changed is just as important. It does not know what your business needs, so someone still has to decide what to build. It does not own the consequences, so someone still has to review, test and stand behind the code. It does not understand your customers, your regulators or the production incident you had last year. And it can be confidently wrong, and it is wrong fastest when the instructions are vague.
So the cost of producing code has collapsed, while the cost of deciding and verifying has not. That shift is the whole story.
The outcomes of using AI, good and uncomfortable
After working with these tools on real projects, the good outcomes are easy to see. Features that took days now take hours, and prototypes that took weeks take a day or two. Experiments become cheap: when building something costs little, you can try three approaches and keep the best one, instead of arguing about it in a meeting. A small, senior team with AI tools can cover ground that needed a much larger team before. Legacy modernisation, the work everyone used to avoid, is suddenly far more practical. And engineers spend more of their time on design and problem solving, and less on typing the same patterns again.
The uncomfortable outcomes are just as real. Review becomes the bottleneck: a team that produces far more code with the same review capacity simply ships more bugs, faster. Quality varies, because generated code can look polished and still be subtly wrong, insecure or inefficient. Technical debt arrives on day one, because code that nobody on the team really understands is debt from the moment it is merged. Skills can erode, as junior engineers who never write the hard parts themselves may struggle to review them later. And there is false confidence: a demo that works is not a system that works under real load, with real data and real users.
None of this is a reason to avoid AI. It is a reason to change the process around it.
Five things breaking in Agile right now
First, the bottleneck has moved. It is no longer writing code. It is deciding what to build, reviewing what was generated, and testing it properly. Most Agile processes still optimise for the old bottleneck.
Second, estimation is losing its meaning. If a 13 point story takes three hours, what was the 13 measuring? Points were a proxy for effort. When effort shrinks and becomes far less predictable from one task to the next, the proxy stops working.
Third, users cannot keep up. You can build every day, but customers do not give feedback every day, and stakeholders cannot absorb a new release every afternoon. How fast we learn is now limited by real usage, not by developer output.
Fourth, the specification matters more than ever. When a machine writes the code, a clear description of intent becomes the real work product. A vague ticket used to produce slow, wrong software. Now it produces wrong software very quickly, and in volume.
Fifth, “done” needs a new definition. “It works on my machine and the tests pass” is not enough when the tests were generated alongside the code. Done should mean reviewed by a person who understands it, tested against real scenarios, checked for security, and explainable by the team that owns it.
What is not dead
To be fair, the Agile Manifesto itself is not the problem. Read it again and it holds up remarkably well: individuals and interactions over processes and tools, working software over comprehensive documentation, customer collaboration over contract negotiation, and responding to change over following a plan. If anything, these values matter more now. When building is cheap, responding to change is easy, and working software can be in front of a customer in days.
What is dying is the ceremony: the fixed two week box, the points, the velocity charts, and meetings sized for a slower world. We kept the rituals long after the conditions that created them had changed.
What replaces it
I do not think the answer is a new framework with a new certification. But the shape of the work is changing, and teams that adapt early will have an advantage. This is the loop I see working:
- Intent: write down clearly what you want and why. This is now the most valuable artefact the team produces.
- Generate: let AI tools do the bulk of the building, with engineers steering.
- Verify: review, test and check security with real rigour. This is where the saved time should go.
- Ship: release small changes often, behind feature flags where needed.
- Learn: watch real usage and feed it back into the next intent.
The cycle is measured in hours or days, not weeks, and planning becomes continuous rather than a fortnightly event. A few practical changes follow from it. Plan review capacity, not coding capacity: the question is no longer how much we can build this sprint, but how much we can properly verify. Measure outcomes, not output, because velocity counts work done while what matters is whether users and the business got what they needed. Treat senior judgment as the scarce resource, because architects, product owners and reviewers are now the constraint. And keep people close to the code, rotating who writes the hard parts by hand, so the team can still review what the machines produce.
The manifesto can stay. The sprint needs a rewrite.
Are we heading into the era of fixed cost projects?
This is the question I find most interesting, especially as someone who works on consulting engagements. The software industry moved away from fixed price projects for good reasons. They failed again and again, because nobody could predict how long the work would take or exactly what the client would need by the end. Agile and time and materials billing were, in part, a response: if we cannot predict the effort, let us bill for the time and adjust as we go. AI changes one half of that equation.
There is a real case for fixed cost coming back. Effort is shrinking and becoming more predictable, and when the building itself takes days rather than months, the biggest source of overruns gets smaller. A working prototype can now come before the contract, which removes much of the “that is not what we meant” risk before anyone signs anything. Clients will also ask the obvious question: if AI does much of the work, why are they paying for hours? And a team that knows its AI assisted delivery well can quote a fixed price and keep the margin it earns through efficiency.
The case against is just as strong. Scope uncertainty has not gone anywhere: AI made building cheaper, not deciding. Clients still change their minds, markets still move, and requirements still emerge only when people see the software. The hard parts are still hard, because integration with legacy systems, data migration, compliance, security reviews and organisational change do not get much faster with AI. The last 20 percent is still the last 20 percent, and getting from a convincing demo to a production system people can trust is where projects slip. Finally, someone has to carry the risk. In a fixed cost deal, whoever carries the risk captures the savings, and also the losses. That is a commercial choice, not a technical one.
My guess is that we will not go back to the big fixed price contracts of the past, with a two hundred page specification and a delivery date a year away. But I do think we will see much more of small fixed cost slices, where a clearly defined outcome is priced up front and delivered in days or weeks before the next slice begins. We will see prototype first, price second: a short paid discovery that ends with working software and a fixed quote for the rest. We will see outcome based pricing, paying for a result such as a migrated system or a working integration instead of for hours. And we will see subscriptions for ongoing work, a fixed monthly fee for a team that delivers continuously instead of a timesheet.
In other words, fixed cost may come back, but in much smaller pieces, with the uncertainty handled by short loops rather than long contracts. Which, if you think about it, is very close to what the Agile Manifesto was asking for in the first place.