Agile is Dead. Long Live Agile.
The software industry has always had a fraught relationship with agile. The ideas that emerged from a scene of developers in the late 90s were genuinely impactful. But over time, the scene was co-opted by sociopaths and grifters, looking to train and certify and gatekeep. And that’s the agile that most people know.
The current era, the one dominated by agentic thinking, believes that it has finally transcended it all. With a single prompt, you breathe life into your product, skipping the drudgery of planning and coordination altogether.
No stories.
No spikes.
No prototypes.
Just pure, unadulterated code, jumping to Git repos so fast that soon, version control will be dead too.
What would’ve taken a two pizza team a full two week sprint can now be completed by a single starved (peptide-filled) engineer in a couple of hours. (Side note: Have you seen the price of pizza lately?? Aren’t you glad we can redirect those dollars to the token budget?)
It’s a software engineer’s idea of utopia. Gone are the meetings, the tickets, and the nagging product manager.
The only thing that matters is code.
Shipping more code, and shipping it faster, is the only way to escape the permanent underclass.
Of course, if this were true, our industry would’ve already morphed itself to capitalize on that brave new world. The quality and quantity of software in such a world would surely 10x, if not 100x.
We all recognize that’s not the reality.
The slop factories are pumping out shit at record pace, while simultaneously grinding real progress (outside the research labs) to a screeching halt.
It’s true: our world is changing.
Large language models are a real paradigm shift, and the industry that birthed them may be its first casualty. But we’re making a grave error when we view LLMs as machines that do some thinking and then do some typing.
Thinking and typing has never, ever been a real bottleneck in the software development lifecycle. Fred Brooks made this clear in Mythical Man-Month, published fifty years ago, and we have apparently learned nothing since:
“adding manpower to a late software project makes it later”
Agents are manpower. And you can’t ramp your token spend to infinity and expect more work to magically get done. There are huge downsides of this philosophy that we’re sweeping under the rug, and massive consequences to face down the road.
So, if throughput has never been the bottleneck, what the hell are we even doing? How are we going to be sure that software doesn’t eat itself, and leave the rest of the world in shambles? When are we going to develop good habits that allow us to fully harness the power of new technologies to truly, actually innovate?
Those habits, they already exist, inside this big little idea called agile. And you’ve already lived them, even if it was just going through the motions. Maybe you do them in vain, and you poo-poo the ceremonies and the tickets and the documents and all of the other theatre that comes along with it.
But it’s not agile’s fault that the professional managerial class bastardized the original thinking into a product of its own. Agile was never supposed to be a job within a job, but thanks to “coaches” who’d never actually shipped software, it developed a reputation as meaningless busywork.
Most companies that sustainably ship valuable products are agile, even if they say they aren’t. Quietly, without ceremony, often without using the word. They don’t believe in the principles, they know them.
And, today, you see the same people who loudly eschew agile thinking re-inventing it from first principles. What are Plan Mode, Spec-driven Development, Evals, and Subagent Tasks if not a rediscovery of tried and true agile principles?
The only problem with these newfangled methods is that they are engineer-brained. They focus on the inverse of agile principles: an emphasis on processes and tools, comprehensive documentation, and following plans, rather than on the interactions of individuals, working software, and being prepared for change. There’s a removal of human collaboration, and a desire to build a master plan, which must be followed to the letter.
Ultimately, this stuff isn’t complicated, but it’s not easy either. The principles help to wrangle the messy parts of software development: the people, uncovering value, juggling priorities, and being able to clearly see where you’re headed.
This stuff isn’t going anywhere, it’s just waiting for us to call them by it’s name once again.
So, yeah:
Agile is dead. Long live agile.
Long time king welcome back!