
In short
- Agile and Scrum were both built around the idea of rationing scarce human effort and moving information between people. AI coding agents have completely changed that economic model and the bottleneck has now moved from writing the code to knowing what is true.
- A lot of the ritual knowledge that used to be transmitted in one direction is now in a shared knowledge base that both humans and agents can read and write to. Context is queried rather than broadcast and the human role has moved from that of a conduit to that of a decision maker.
- We now treat knowledge as the real source code and software as the artefact that's compiled from it. That's what we call Knowledge Centric Delivery.
- At Rootstrap it's on Rootshift (our delivery method) and is now evolving into Rootshift Teams where specialist bots are working through the same gates as people, with humans in control of what is true.
Agile got us here. We don't work that way any more.
It taught a generation of engineers (me in that generation) to ship small, to listen to the users and to change direction with absolutely no shame. I owe it a huge amount.
Nobody called a meeting to say it. In a matter of months we were effectively no longer building software the way we'd been building it for our entire careers. The rituals were all gone, the bottleneck had moved and the thing we were actually managing was no longer code.
I want to state what happened and be absolutely clear about what we now believe. Some of you are going to disagree with that. That argument is valid. I also want to make the case that this is the best time ever to be a software engineer.
Agile solved a problem we no longer have
Agile was one of the great ideas of our trade. It got rid of the massive upfront plan. For us it's all over and done with. So is Scrum. The Agile rituals (sprints, stand ups, story points, velocity, planning poker etc) no longer structure our work and I think that era of software is now over.
The best bit was never the ceremonies really. It was the learning in the face of uncertainty. Build something small, show it to someone and find out you were wrong and then fix it. We need that as much as ever.
What we no longer need is the machinery that grew up around it. Look at what each piece actually does. Sprints ration effort. Story points are an estimate of effort. Standups are for synchronisation. All of it was there to protect a finite resource: engineering hours. That was the context in which we were writing code and it was a very expensive thing to do. And a significant proportion of the machinery was simply there to move information from one person's head to another's.
That was an economy of effort and the economics were different. When the problem moves and the solution is left behind the solution becomes a ritual.
Where did the bottleneck disappear?
AI coding agents can now write the code, generate the tests and review the changes (all of them at once). That doesn't make delivery free though. There's still a cost in terms of review, integration and failed attempts. In our work at least, it's no longer the implementation that sets the pace.
The bottleneck has moved upstream to the questions the agents simply can't answer for us. What is actually the case with this business? What must this system do and what must it absolutely never do? What does the contract actually promise? Who gets to decide?
Software development is getting easier. The bit that's still hard is working out what is true and what we actually want. What we're managing now is knowledge.
I made a longer case for this in The Assumptions Behind Software Engineering Are Expiring.
What is Knowledge-Centric Delivery?
Knowledge Centric Delivery is a way of building software where knowledge is the source code and the software is the artefact that is compiled from that knowledge. Agile works by organising people around code. Knowledge Centric Delivery works by organising knowledge and the code is derived from that.
It's first and foremost a mental technology. Agile wasn't ever really about sticky notes. It was a way of thinking that happened to be accompanied by a process. I didn't invent the notion that software is knowledge. That's been the view in our industry for decades. What's changed is that with agents doing all the typing we can finally run a team on it.
The vision, the decisions, the contracts and the rules that we've agreed are true are the source. The code is what the agents produce when they compile that source into something a machine can run.
Take the hypothetical case of a cancellation flow which immediately cuts the customer off rather than allowing them to have access right through to the end of their billing period. The first question you ask isn't 'which line has broken' (though that's obviously the next thing you look at). The first question is 'was that rule ever actually written down at all'?
If it was actually written down and the agent got it wrong then fix the code. If it wasn't written down at all then write the rule first, add a test and then fix the code. Otherwise the rule lives nowhere and the next agent or engineer to touch that flow is going to just go and undo the fix without knowing what it was protecting.
Approval gates are the compiler rejecting bad input. We won't build from knowledge that is ambiguous, contradictory or not yet approved because that's the cheapest place to catch a mistake (nothing's been built on top of it yet).
The source also outlives the compiler. The models and stacks will change (they probably will several times before this post turns one) and sound knowledge is what enables you to rebuild when that happens.
The metaphor breaks in two places. Agents are not deterministic so you could compile the same knowledge twice and end up with different code, and a clear decision can still be implemented badly. Approved knowledge isn't necessarily true. A room full of people can be in agreement about something that's completely wrong. That's why we have gates, we have verification and we have human judgement. The metaphor is telling us where the guard rails go, not that we can dispense with them.
Truth also flows back. If a test fails in a way that nobody in the team had anticipated, or if a feature actually gets used by a real user, you learn where the knowledge was wrong and that lesson goes back into the source. That loop is where Agile's instinct for learning actually lives.
Many Agile rituals were a way to move information
Have a look at a Scrum calendar and ask what each meeting actually does. The standups are for status. Planning is for moving the priorities from the product owner to the team. Refinement is for moving a requirement from the person who actually understands the business to the people who are going to build it. The reviews and the retros are for moving what happened back to everyone else. The tickets and the handoffs do the same job in writing.
A lot of that was a transmission system really. It was there because knowledge resided in people's heads and heads don't synchronise on their own.
Every transmission loses something. A requirement is explained in detail, then distilled into a ticket, then re-explained by the person who picks it up and then again in the review when the outcome is wrong. Each hop adds noise. The person who missed the meeting gets a second hand version. The person who joins in month six gets a third hand version. Sharing context between humans was an enormous effort and we paid that cost every day without ever really noticing because we called it process.
With a shared knowledge base (i.e. the Ground Truth) a lot of that information no longer needs to travel that way. It's written down once, a named individual owns it and its evolution and anyone who needs it (whether human or agent) just reads it when they need it.
Go back to the cancellation rule. In the old world it was in the refinement, retyped into a ticket and then the reason for it was clarified in a standup answer which only existed in the memory of the person who was there. In the new world the rule, the reason for it and who approved it is all in the Ground Truth. The agent that's building the flow and the reviewer both read the same text. A shared source doesn't mean a shared understanding. People and agents can still interpret the same rule in very different ways. There is just one place to resolve the disagreement and record the answer rather than having five copies of it going in different directions.
Even the standup update has changed. "I'm not sure whether access ends at cancellation" is no longer something you're going to say out loud in the hope that the right person will hear it. It's now an open decision, sent to the owner and visible to all the work that depends on it.
Context is now a different activity. Context is queried rather than broadcast. Humans and agents all read from and write to the same source and what one of them learns, the others can read the next time they need it.

Previously context would be passed from person to person and get a bit lost in the process. Now people and agents are all reading from and writing to one single shared Ground Truth.
The human's job is of course very different. It's not any longer about passing information between people. It's about deciding what's true, resolving the ambiguities that the agents bring to the surface, judging when something that is correct is still wrong, approving what fits the vision and writing what they've learned back into the source.
Some conversations still matter and I won't pretend they don't. People build trust, they argue openly and they make the tough decisions together and no document can ever replace that. Those conversations are for the decision making, not for the information transfer. A meeting that's just about moving information is a bug report on the knowledge base.
How it works at Rootstrap: Rootshift
At Rootstrap we built that way of thinking into a delivery method that we call Rootshift. The easiest way to explain it is to go through the cancellation rule.
The rule is in the project's Ground Truth (alongside the vision, the decisions and the contracts we've approved with the client). Agents read it. People curate it. I've written in some detail about its structure in Why AI-native delivery needs a shared Ground Truth.
Before an agent touches the flow there's a readiness gate which checks that the work is on approved truth. If the rule is missing or not yet approved then the work goes back to a person.
Then the AI coding agents pick up the tickets in parallel, each in its own fresh context. The PR points back to the rule that it implements so you can ask "why does this code exist?" and get an answer. The same rule applies to the review and the tests rather than it being rediscovered on every ticket.
Reviewer agents and automated tests will check every change and a merge gate will reject anything that comes in without the appropriate verification evidence. In this case that would be a test which proves access continues right up until the end of the period.
Some changes absolutely must not be made by a machine on its own. Where a change involves secrets or security, client data, the agreed vision or a contract, or where it is potentially destructive, a vision gate is triggered and it is held up for a human. If our billing rule is straight out of a contract then a human will look at it, make the decision and own that decision.
Every action and every gate leaves a trail and the friction comes back as new knowledge. We still look back at what went wrong, just without the ever-present calendar invite. The lesson gets into the Ground Truth where the next agent will actually read it.

The cancellation rule's journey through Rootshift: approved in Ground Truth, checked at the readiness gate, built by the parallel agents, verified at the merge gate, held for a person at the vision gate if it touches something sensitive and what each delivery teaches gets fed back into the source.
And the client keep everything. The code and the IP stay with them, no platform to rent, no proprietary runtime. All we leave behind is the codebase and the knowledge to compile it.
A warning to us all: governance can become the new ceremony. Approvals nobody ever reads, checklists ticked off to satisfy a checklist. That's how Agile became theatre in so many organisations. Every gate has to name the risk it controls and have to justify its cost. A security gate may be very rare in its firing but can still be absolutely vital. Any duplicate approval with no real purpose should be eliminated.
The same trap applies to Ground Truth. A knowledge base that nobody maintains is just documentation with a better name. It only works if every entry has an owner, a changed rule triggers the work that depends on it and what we learn actually gets written back. That takes effort and we're still working out how much effort is required.
How people and agents split the work
Agents write, test and review in parallel and they never get tired of running every check on every change. They make the same mistake every time, with the same conviction. The split is obvious. Agents produce and verify. People are the ones who decide what is true, what evidence is sufficient and what will never ship on the basis of a machine's assertion. Matias Mansilla draws that line in Human in the Loop for AI Agents: Judgment, Not Verification.
The time that used to be spent on estimation, synchronisation and status reporting is now spent on deciding what's true, reviewing that truth and refining it. The problem is of course if the time you spend reviewing the agent output is in fact the time that the agents have saved then you've just moved the bottleneck again. The actual design work is in the collaboration itself: making sure that human attention is focused where it's most valuable.
Where it is heading: Rootshift Teams
We're now building the specialist bots via Rootshift. We have a Manager bot which talks to people on Slack and surfaces the decisions that require a human. We have role-based worker bots (developers today, QA and others next) which will be overseeing the coding agents, picking up the work, flagging any friction when something doesn't fit and writing back what they've learned into the Ground Truth.
The bots go through the same gates as everybody else. A Manager bot can pass on a contract change to the right person, it can't approve it though. Each team is headed by a Senior Rootstrap engineer who owns the judgement and guards the vision.
That's what we call Rootshift Teams: humans and bots working from a common source of truth, with the humans in control of what is true.
The source and the artifact
Nobody has a map. Not us, not the tool vendors and not whoever eventually sells the first certification. I'm talking about how we work and what we believe, not a finished method. Some of it will be wrong. That's what a frontier looks like. The practices that will define the next decades of this profession are being worked out right now by the people who are prepared to be wrong in public.
For most of its history software engineering was the art of taking thought and turning it into code by hand. The thought was all over the place in meetings and in people's memories, passed from person to person and inevitably lost at each hop and the code was the only thing that survived.
That relationship is now in reverse. Code is becoming cheap and disposable. What endures is the thought itself: the clear, owned and living understanding of what is true and what we want. The artefact can be recreated. The source is what we have to protect.
Protecting it doesn't mean freezing it. A decision that's been written down can be challenged and a failed test can in fact reveal its limitations. You can't call something Ground Truth and then in effect put it beyond any possibility of revision.
What this software should be able to do and who will be answerable for what it does? No agent can take that question off our shoulders.
For years the difficult bit of our job was working out what to build and what it absolutely must not do and we'd squeeze that thinking into the gaps between typing and the meetings we needed to have to keep each other informed. That thinking is now the job. That's why I think we're in the best era of software engineering ever.
Frequently asked questions
What is Knowledge-Centric Delivery?
It's a model of working where the approved, owned knowledge about the product (its vision, its decisions, its contracts and its business rules) is what the team maintains. The AI coding agents build from that, the code is validated against that and what delivery teaches gets fed back into that. A lot of the information that used to be passed from person to person in the Agile rituals now lives in that central knowledge store where both humans and agents can read it.
Is Agile dead in the age of AI agents?
At Rootstrap we've moved on from using Scrum sprints, ceremonies and estimates as our delivery framework and I think that era is definitely over. The core idea of Agile (i.e. learning in the face of uncertainty by building, showing and adapting) remains at the heart of whatever comes next. Sprints, story points and standups were all designed to ration a scarce resource (human effort) and to move information between people. With AI agents and a shared knowledge base the nature of both of those has changed. For a take on which of the Agile principles still apply, see The Future of Agile in AI-Native Software Development.
How is Knowledge Centric Delivery any different from spec driven development?
There's genuine overlap and the pieces aren't new at all (specs, docs-as-code, CI and agents all pre-existed). The test case I'm interested in is what happens when a decision changes. In Rootshift knowledge has owners and approval states, work references the decisions it is dependent upon and if a source changes then the knowledge that is dependent on it goes back to needing revalidation before anything can be built upon it. Gates will not build from knowledge that is ambiguous, contradictory or not yet approved. That's the principle that is applied throughout the delivery loop, not just at the specification stage.
What are Rootshift Teams?
Rootshift Teams are specialist bots that operate via Rootshift (Rootstrap's delivery mechanism) in conjunction with humans. There's a Manager bot which works with the team and raises up the decisions that require a human. There are then role-specific worker bots which oversee the coding agents and write what they've learned back into the Ground Truth. Each team is led by a senior Rootstrap engineer.


