Watching the erosion of what Agile actually taught us - and why the agent era makes it feel irrelevant just when it matters most.
I've been in software for over twenty years. Long enough to have lived through what we called Agile, not as a poster on a wall, but as habits that actually changed how teams worked.
Lately I've been watching those habits quietly erode, and it's making me uneasy.
What Agile actually was
Strip away the certification industry, and underneath was a bundle of things that worked: small batches, continuous integration, code review, retrospectives, collective ownership, the stand-up.
Notice what they all have in common: none of them is about individuals. They're about coordination between individuals. Every one exists because a group of people working on one thing will reliably drift apart - in understanding, in direction, in quality - unless something pulls them back together.
Agile, at its best, was a collection of drift-correction mechanisms. Twenty years of engineering culture, bought with real failed projects, distilled into practices that kept teams from flying apart.
Why it's eroding
Nothing I've listed has been disproven. The premise underneath it has shifted.
The premise was: software is built by teams, and communication between people is the expensive part. So we built practices to make that communication cheap and frequent.
Then agents arrived, and one person with a clear brief can now produce in a day what took a team a fortnight. I've lived this. I run a platform built on agents. The feedback loops have collapsed.
And the seductive logic follows: if I can do all this alone, why do I need practices that exist to help teams coordinate?
Stand-ups feel redundant when your team is you and five agents. Code review feels redundant when a second agent can critique the first. Some of this is even true. But something is being lost, and I want to name it.
What we're actually losing
The mistake is confusing the mechanism with the reason.
The stand-up was never about standing up. It was about a group holding one shared, current model of reality. Code review was never about typos. A second mind, with different blind spots, looking at your work is one of the strongest error-correction mechanisms we have.
And here's the problem:
An agent will not give you genuine disagreement.
I've refereed arguments between agents. It looks like disagreement, but it's a performance, requested on demand. The most valuable disagreement I've known in twenty years was never the argument - it was the quiet disagreement. The colleague whose silence tells you something is wrong. The tester who keeps finding edge cases. The junior whose naive question exposes an assumption nobody stated. Agents are agreeable by design. The friction between people who are differently invested is where the quality came from. You cannot prompt your way into it.
There's a second loss
Shared understanding doesn't decompose into individuals. When each person works alone with their own fleet of agents, each person's understanding is private. The organisation knows nothing. That's why a good team survives losing its best developer and a collection of brilliant individuals with agents cannot.
And the erosion is happening by omission, not decision. Nobody voted to abandon code review. It just fades, because nobody's in the flow to do it. That's how cultures lose things - through drift. And drift is precisely what these practices were invented to correct. We're dismantling drift-correction mechanisms because, briefly, we don't feel the drift.
Why it's dangerous
Software doesn't fail in the moment it's written. It fails later - when requirements change, when the person who understood it leaves. Twenty years of practice taught us the cost of software is mostly later.
The agent era optimises ferociously for now. Now is where the demos are. A team shipping three times more than last year looks like a success. The fact that nobody but the person who prompted it understands what shipped is invisible in any dashboard, until the day it isn't.
We removed the guardrails because the car got better. The car has got better. But the roads haven't, and the other drivers haven't. The guardrails were never there for the good days.
What to keep
I'm not arguing we go back. But keep the functions, not the forms:
Keep the second mind. Nothing important ships having been seen by only one intelligence.
Keep the shared model. Whatever replaces the stand-up must answer: does the group hold one current picture of reality? Mostly this is unsolved, and it should worry us more than it does.
Keep small batches. Cheaper iteration doesn't repeal the law that you don't know what's right until reality tells you. The failure mode now isn't big batches - it's unexamined batches.
Keep the retrospective. The unit of learning is still the team, not the individual.
Keep the ownership. Agents have no stake in the outcome. The stake has to live somewhere, and it can only live in people.
The honest bit
I might be wrong about the magnitude of this. Maybe the new coordination patterns are being invented right now, and in three years I'll look as dated as the RUP manuals. It's possible. I've built a company on the belief that the old rules don't all apply.
But what made Agile good was never the rituals. It was a set of truths about humans making things together: that we drift, that we're wrong more often than we think, that disagreement freely given beats agreement on demand, that the cost of everything is mostly later.
Agents are magnificent at the individual. They can do nothing about the collective. The collective still exists.
The practices were how we taught ourselves to serve it. We're about to spend a few years pretending we never needed to learn it. I think we'll pay for that. I'd rather we didn't.
Lewis Barclay builds Odokai, a private AI platform for teams that want agents without giving up ownership, auditability, or - as this piece argues - each other.