Agile to AI-Native
Transcript
Made automatically from the video's sound, so it may contain mistakes. Click a line to play from there.
Welcome back to the grand finale of our Ways of Working series. We've been tracking some absolute seismic shifts in software engineering. And today, today we're tackling the biggest question out there right now. Has artificial intelligence finally killed Agile?
Let's get straight into it. Here is the roadmap for this explainer. One, the AI versus agile clash. Two, what changes and what survives.
Three, the case that agile is dead. Four, the case that agility lives on. Five, the hard empirical data. And six, the 2026 AI native synthesis.
Section one, the AI versus agile clash. Spec-driven prequel to the 2026 debate. Just a quick recap from our last explainer on spec-driven development. Because AI makes generating the actual code practically free, human effort is drastically shifting upstream.
We're now focusing on creating incredibly crisp specs and robust test harnesses, and we're leaving the raw code generation to the AI. Which brings us to the massive elephant in the room. If code generation is essentially free and instantaneous now, do those slow, human-paced agile rituals actually make any sense anymore?
Is Agile literally dead in the age of AI? Section two. What changes, what survives? The shifting sands of software development.
We really need to separate the shifting sands of coding from the fundamental laws that stubbornly survive. On the changing side, Simon Willison notes that the cost of prototyping, or spiking, has completely collapsed.
Using disposable code from tools like Spec Kit, one single engineer can test three working options faster than a traditional scrum team can even estimate a single ticket. But on the surviving side, well, AI absolutely cannot compress Marty Kagan's product discovery.
You still have to figure out what the user actually wants. And as Team Topologies points out, human cognitive load ceilings aren't going anywhere. Our brains can only handle so much complexity, no matter how ridiculously fast the AI types.
Section 3. The case. Agile is dead. Death of the backlog and performative sprints.
Now, this isn't just some edgy tech bro opinion. This is from Ron Jeffries, literally one of the original authors of the Agile Manifesto. He argues that developers should just abandon commercialized agile, or dark scrum.
For years, Enterprise Agile has been way more about micromanagement and performative rituals than actual agility. And here's exactly why those old rituals are buckling under AI. Look at SourceGraph's vision for developer agent fleets.
Picture a single developer acting like a line manager, directing multiple AI agents working in parallel on bugs and new features, burning thousands of dollars a day in tokens. When you're managing massive parallel AI output with huge productivity leaps, a rigid two-week human sprint isn't just slow, it actually becomes the bottleneck.
Plus, Paul Graham's classic makers schedule manager's schedule essay highlights another fatal flaw. Managers run on one hour increments, but makers need half day units of deep, uninterrupted focus.
Commercial Agile forces makers onto a manager's schedule, completely fragmenting their time with daily stand-ups and backlog grooming. When you're managing high-speed agent fleets, you need deep context. You just can't afford that traditional agile fragmentation anymore.
Section 4. The case. Agility lives on. Building the wrong thing faster is still waste.
But hold on. Before we completely bury Agile, let's look at the flip side. This brings us back to the original Agile manifesto. Specifically, principle number 10.
Simplicity. The art of maximizing the amount of work not done is essential. Think about it. If you use AI to build the totally wrong feature 10 times faster, you haven't actually increased productivity, right?
You've just created a massive amount of waste, 10 times quicker. Bergita Bechele from ThoughtWorks sums this up perfectly with a brilliant German word for Schlimmbesserung, making something worse in the attempt to make it better. If we just blindly cram AI into our old heavy workflows, we're just going to amplify hallucinations, generate heaps of unreviewed code, and trigger systemic code rot.
Section 5. The hard empirical data. Measuring the real world impact of AI coding. So here's our steel manned debate matrix.
On one side, we have Agile being dead due to agent fleets and disposable code. On the other side, true agility is vital to manage product risk. And AI without CI CD safety nets just causes code rot. To settle this tie, we really need to look past the philosophy and dive into the hard empirical data.
Brace yourselves for this next data point, because it is an absolute game changer. In early 2025, METR ran a rigorous randomized controlled trial with experienced open source developers. The results?
Well, when using Frontier AI models, devs felt like they were 20% faster, but the objectively measured reality, they actually took 19% longer to complete their issues. There's a staggering gap between perception and reality there. AI feels incredibly fast at generating code, but the time spent debugging, reading, and fixing it severely dragged down actual throughput.
So, why the slowdown? The 2024 Doral report hits the nail on the head. AI massively inflates pull request batch sizes. It acts as an amplifier for whatever existing dysfunction you have.
If your testing is poor, AI amplifies that, causing surging code duplication, something GitClear's studies have heavily documented too. Dora found that increased velocity from AI directly causes instability, unless you have strict CICD safety nets.
The single most critical countermeasure to survive this chaos? Working in small batches. Section 6. The 2026 AI native synthesis, how high performing teams actually work.
So, how are high performing teams actually operating to balance all this out? First off, they are absolutely binning those endless demoralizing backlogs. Taking cues from ShapeUp and Linear, they're shifting to decentralized lists and making concrete six-week bets instead.
Second, they're utilizing long-running agent harnesses, like the ones from Anthropic, guided by intent-driven natural language specs. And finally, they're organizing into small empowered product pods, exactly like Silicon Valley Product Group recommends, where engineers talk directly to users to make sure they're actually building the right thing.
To distill this synthesis down into three actionable steps for your team. Step one, kill performative scrum estimation. Stop wasting hours pointing tickets for a backlog you'll literally never finish. Step two, double down on Dora's small batch DevOps discipline.
I'm talking crisp specs, test driven harnesses, and strict PR batch caps to survive the sheer volume of AI output. And, step three, empower your cross functional pods to bypass the management layers and talk directly to your customers.
Which leaves us with this final thought. Commercial Agile, that heavy, meeting stuffed process we've dealt with for a decade, is indeed dead. But the true agility to discover what users actually need, keep batches small, and adapt fast, that is more critical now than ever before.
So the real question is: is your team ready to stop sprinting and start working with true AI-native agility? Thanks so much for joining us for this series, and we'll see you in the next Explainer.