Is Agile Dead in the AI Era
Transcript
Made automatically from the audio, so it may contain mistakes. Click a line to play from there.
Picture a modern engineering organization in late 2026.
Okay. I'm picturing it.
So on one side of the office, or you know, on one side of the company Slack workspace, you have a single developer.
Just one.
Just one. And they are sitting there orchestrating a fleet of AI coding agents.
And we really need to emphasize we aren't talking about autocomplete here.
No, absolutely not. We're talking about autonomous, agentic workers. And in exactly 90 minutes, this single developer prototypes three fully working, completely distinct, and highly complex versions of a massive new feature.
Which is just a staggering amount of output.
Right. 90 minutes. Three working versions ready for user testing.
When you actually sit down and watch someone do this, I mean it feels like watching time-lapse photography.
It really does. But here is the contrast, because this is the reality of our industry right now. In that exact same 90-minute window, literally one virtual room over on Microsoft Teams or Zoom, you have a neighboring scrum squad.
Oh, this is gonna hurt.
Yeah. They are locked in a sprint planning meeting, and they are passionately, fiercely arguing over whether a specific JIRA ticket, like I don't know, updating a database schema or something, is a five or an eight in Fibonacci story points.
The juxtaposition is almost physically painful to witness.
Right.
You have this hyper acceleration of raw output on one side, and then just total bureaucratic paralysis on the other, both happening under the same corporate roof.
Sometimes within the exact same engineering department, and here's where it gets really interesting. Okay. Comparing these two realities happening in the exact same 90-minute window, it's like watching someone bring an abacus into a quantum computing lab.
That is exactly what it is.
It highlights this completely absurd, almost comical tension happening in modern tech organizations right now. Are we measuring human effort or are we actually delivering software?
That is the big question.
And that sets the stage perfectly for what we are doing today. Welcome to the finale of our deep dive series Ways of Working from Agile to AI Native.
It has been a seriously long journey to get here.
It really has.
Yeah. As a strict prerequisite, we are assuming you, the listener, have been with us for the ride so far.
Yeah, we aren't going to re-explain the basics today.
Right. No re-explaining DevOps or how a Kanban board works or waterfall versus agile. You already know that.
Absolutely. Last time in episode five, we explored how spec driven development uses AI to shift the developer's focus from writing syntax to drafting durable, executable specifications.
That concept is basically our launch pad for today.
Which brings us to the inevitable climax of this entire series. We are taking on a mission today to answer one central, highly contentious question.
The one keeping engineering directors awake at night, right now.
Exactly. Is Agile dead in the age of AI?
It's a huge topic.
It is. And we are going to run this as a sharp, respectful, steel manned debate.
No pulling punches.
No pulling punches. I am going to take the position that commercial agile, you know, the frameworks, the ceremonies, the endless certifications, is completely irrevocably dead. It is a relic.
And I will be arguing the counterpoint to that.
Right.
I'm gonna argue that while the bloated commercialized frameworks might be failing under the weight of their own bureaucracy, true agility matters more now than it ever has in the history of software engineering.
I love it.
I mean, the core principles of fast feedback loops, direct user discovery, adapting to change, those are critical.
And to everyone listening, whether you manage an engineering team or maybe you're a product manager or just a developer who is incredibly tired of sprint retrospectives.
Which is all of us.
We promise you there will be no straw man arguments here today. This is going to be a clash of hard empirical data versus cutting edge practitioner reality.
Let's get right into it.
Okay, let's unpack this. I'll take the floor first to lay out the really aggressive reality of 2026 AI and native development. Go for it. I want to build on that cold open of the single developer acting as this hyper productive conductor of agents. Because my first core argument is that the commercialized version of Agile was already deeply broken well before large language models even showed up.
You talk about the bureaucracy.
Exactly. We are talking about the death of what Ron Jeffries, who was one of the original founders of extreme programming, what he calls dark scrum.
Oh, dark scrum. Yeah. We should define that. That's the phenomenon where agile frameworks are essentially weaponized.
Weaponized, yes.
They get used not to empower developers to make decisions, but to micromanage them, track them, and essentially oppress the engineering process under the guise of quote unquote transparency.
Exactly. It's control dressed up as agility. And Dave Thomas, who was one of the original 17 signers of the Agile Manifesto, he wrote this incredibly prescient piece all the way back in 2014.
Way before AI was in the picture.
Right. And he pleaded with the industry to abandon agile as a noun.
Yes.
He pointed out that Agile had been completely subverted into a meaningless marketing term, a brand name. You can't do agile. It's an adjective. You can develop with agility.
But the moment it became a noun, it just became this massive magnet for consultants, right?
Exactly. Consultants hawking two-day certifications that just instituted these top-down control mechanisms.
It became an entire industry of compliance rather than an actual philosophy of software delivery.
Right.
You had teams proudly declaring they were doing agile simply because they had a daily stand-up, but they were still deploying software to users once every six months.
Yes. And that exact compliance culture completely wrecks the developer's day.
Oh, totally.
If you're listening to this and you lead an engineering team, just think about your own calendar tomorrow. Look at how many one-hour blocks are dedicated to backlog grooming, sprint planning, and retrospectives.
It's exhausting.
It is. I want to bring in Paul Graham's concept here: the maker schedule versus the manager schedule.
A classic essay.
So relevant here.
So relevant.
Managers operate on a schedule that's sliced into one-hour blocks. A meeting at 2 p.m. is just a slot on the calendar for them.
Right. They just jump from context to context.
But developers, makers, they need half-day blocks of uninterrupted time. They have to hold massively complex systems in their heads just to actually build things.
Because writing software requires loading a huge amount of context into your working memory. The architecture, the variables, the data flow.
Exactly. And traditional scrum ceremonies slice a developer's day into a manager's schedule.
Daily stand-ups, backlog groomings, brand planning.
Right. These recurring ceremonies chop the day into useless one-hour slivers. As Paul Graham points out, a single meeting can completely blow a whole afternoon for someone on a maker schedule.
Because it breaks the afternoon into two pieces that are just too small to do anything hard in.
Yes. It changes the mode in which you work. It's practically like throwing an exception in your brain.
Unloading all that context and then having to reload it takes immense cognitive energy.
So Dirk Scrum was already bleeding developer productivity dry. We established that. But now, now we have zero cost code.
This is where everything shifts. The economics of software creation have fundamentally shifted from a labor-intensive craft to basically a computational commodity.
And this reality absolutely kills traditional agile artifacts. Things like estimation poker and spike rationing.
Yeah, those just don't make sense anymore.
Why are we sitting in a room for 45 minutes holding up cards with Fibonacci numbers on them to estimate how long a research spike will take when an AI agent can literally just build the thing in 10 minutes?
We are fully living in the world of Simon Willison's agentic engineering now.
Yes. Let's make sure we define that clearly for the audience, though, because the terminology moves so fast.
It really does. So when Wilson talks about agentic engineering, he isn't talking about GitHub co-pilot just suggesting the next line of code in your IDE.
No, not at all. We are talking about agents that don't just generate text. They generate code, they execute it in a sandbox, they read the terminal output.
And they realize they made a syntax error.
Exactly. Right. They realize the error, they rewrite the code, they test it again, and they iterate on it completely independently without any human intervention.
Writing code is cheap now.
It's basically free. I can spin up parallel disposable prototypes in 10 minutes using tools like Quad Code or Ader. And this connects perfectly to Martin Fowler's concept of sacrificial architecture.
Sacrificial architecture is such a fascinating concept.
It is.
Fowler noted years ago that at places like Google or eBay, they would deliberately design a system for ten times its current needs, but they fully plan to completely throw it away and rewrite it from scratch once it hit a hundred times growth.
Right. The architecture was meant to be sacrificed on the altar of skill.
But before AI, throwing away code was incredibly painful.
It was psychologically devastating for a team, and it was massively expensive for the business. You just spent six months of expensive payroll on that code. But now AI makes throwing away code practically frictionless. If the agent wrote it in an hour, who cares if we throw it in the trash?
Right, because the cost of generating the syntax has dropped to near zero.
Exactly. So my argument is basically this. Estimating AI code is like trying to meter the water from a fire hose using a shot glass.
It's pointless.
It is pointless. The velocity is simply too high. And because code is now totally regenerable, we are seeing a total flipping of the Agile Manifesto itself.
Okay, now that is a very bold claim to make. Explain that.
When code is a cheap, disposable byproduct that can just be regenerated in minutes, the value moves up a level of abstraction. The source of truth is no longer the code base itself. The source of truth is the specification. We see this actively happening right now in GitHub Spec Kit and Anthropics Architecture for Long Running Agents.
Let's dig into the mechanics of that. Because the term long running agent sounds simple, but historically, getting an AI to run for a long time has been a total nightmare.
Oh, a complete nightmare.
How does the anthropic agent architecture actually handle this shift toward durable specs without breaking down? Like, why does the agent need a formal spec instead of just a really good prompt?
Because of context window collapse. Right. In the early days, and by early days I mean like a year ago, if you asked an agent to build a whole application, it would try to one-shot it. It would just start writing file after file.
And then it would just lose its mind.
Exactly. LLMs have attention degradation. The longer the context window gets, the more they forget the initial instructions. They lose track of variables, they hallucinate dependencies, and they eventually run out of context and leave you with this half-finished buggy mess.
So Anthropic split the paradigm to solve this.
Yes. First you have an initializer agent. Okay. You give it a specialized prompt, and its only job is to set up the environment and write the spec. It doesn't write the app. It creates a claude-progress.txt file, an init.sh script, and an initial git commit.
It just lays the foundation.
Right. It writes out a comprehensive JSON file of feature requirements, maybe 200 distinct features, edge cases, and test parameters, and it marks them all with a status of failing.
So it creates the durable spec. As you said, it doesn't write the app, it writes the blueprint and the test criteria.
Exactly. And then the coding agent takes over. But here is the brilliant part.
What's that?
The coding agent wakes up in a totally fresh session. Empty context window.
Oh wow.
So no degradation.
None.
It runs a script to get its bearings. It reads the git log, it reads the claude-progress.txt file, and it picks one failing feature from the spec to work on.
Just one.
Just one. It writes the code, it writes the tests, and then it verifies it. And it doesn't just read the code to verify it, it actually uses browser automation like the Puppeteer MCP.
Now, for those listening who might not be deep in the weeds on this new terminology, let's break down what an MCP is. Because it is critical to understanding how autonomous these agents actually are.
Right. MCP stands for model context protocol. Yes. When we say the agent uses the puppeteer MCP, the AI isn't just writing a testing script. Through the model context protocol, the LLM is essentially being handed a set of virtual hands and eyes.
That's a great way to put it.
It boots up a headless Chrome browser, it navigates to the local host server, it just spun up, it clicks the button it just coded, and it reads the DOM to see if the success message appeared.
And if it doesn't.
If it sees an error state, it feeds that visual or text data back into its own context to try fixing the code again.
It is literally executing the scientific method in a micro loop.
Yes. And once the test passes, it commits it to git, updates the progress file to passing, and goes to sleep.
And then a fresh one starts.
Exactly. Then a new agent session starts for the next feature. The code is just the exhaust. The spec, the progress file and the tests, that is the actual engine.
And GitHub Spec Kit operates in a really similar, highly regimented philosophy. They have what they call a constitution for the project.
Yes, the spec kit constitution. It is fascinating. It has nine immutable articles. Right. Article one is the library first principle. Every single feature must begin as a standalone library, completely decoupled from the UI.
Which is just good architecture.
Exactly. Article three is test-driven generation. No implementation code shall be written before tests are written, approved by the human and confirmed to fail.
So the human is still very much driving the constraints.
Yes. The human developer uses a command like spec it.specify to generate the markdown specs, then spec it.plan to create the architectural implementation plan, and spec it.tasks to derive an executable task list.
And then the AI just executes against that spec.
Exactly. And here is the kicker. If the human wants to pivot the product, they do not refactor the code.
They change the spec.
They update the spec and have the AI regenerate the implementation entirely from scratch.
Which fundamentally alters team structures.
Completely.
If a single developer can act as a product manager defining specs, and an army of ephemeral agents writes the implementation, the entire concept of a cross-functional scrum squad just falls apart.
It obliterates the multi-developer scrum squad. We are seeing tiny high-agency pods taking over, and they aren't using two-week sprints. They use frameworks like linear method or base camps shapeup. They work in six-week cycles. They are making bets. They are not managing bloated infinite backlogs.
Let's compare those directly for a second. Why does a six-week cycle fit an AI native workflow better than a traditional two-week sprint?
Because a two-week sprint in traditional agile is fundamentally about micromanaging human output. Right. It's about breaking work down into these tiny chewable pieces so humans don't get overwhelmed, and so managers can track velocity. But an AI doesn't need its work broken down into two-week chunks to stay motivated.
No, it doesn't care.
In ShapeUp, a six-week cycle is a container for evaluating business value. You take six weeks to build a massive, fully realized feature from spec to deployment. And they explicitly ban backlogs.
Which is so refreshing.
In ShapeUp, if an idea is truly important, it will come back. You don't waste hours grooming a backlog of dead ideas from three years ago. You just bring a well-shaped pitch to the betting table every six weeks.
If it wins, you build it.
If it wins, you build it. If it doesn't, it's gone.
And the execution of those six-week bets requires far fewer humans now.
Way fewer. SourceGraph CEO calls it the revenge of the junior developer.
I love that phrase.
A single developer today, managing a cluster of agents, spending maybe $50,000 a year in LLM tokens, can do the work of an entire 2010 scrum squad.
It's incredible.
Steve Yeeg, Adios Mani, all these massive voices in the industry are observing this exact shift. The multi-developer squad, passing story points back and forth, waiting for QA to sign off, waiting for back end to unblock front end. It is just obsolete.
So that is your case.
Commercial agile is dead. It has been replaced by tiny pods, agent fleets, and durable specs. I rest my case.
Well argued. Very well argued. But this raises an incredibly important question, and it is where I am going to push back hard.
All right, let's hear it.
You are describing an incredibly fast, highly efficient, feature factory utopia.
That sounds pretty good, right?
It sounds great, the mechanics you just outlined. The agents, the MCPs, the disposable code. It's all mechanically sound. But this entire vision completely ignores the human element of what to actually build.
How so? The specs tell them what to build. The human writes the specit.specify command, the agent generates the tasks, and the product gets built.
Yes, but where do the specs come from?
From the human.
Right. But you are assuming that the most difficult part of software engineering is writing the code. You're treating the syntax as the ultimate bottleneck. But we have to go back to Fred Brooks.
Okay.
Decades ago. In his book, The Mythical Man Month, Brooks pointed out that we must distinguish between accidental complexity and essential complexity.
Okay, let's define those for the audience. Accidental complexity being the mechanics of coding, right? Compiling syntax errors, setting up boilerplate, fighting with webpack configurations.
Precisely. AI is an absolute miracle at compressing accidental complexity. It drives the syntax cost at zero. It configures Webpack in five seconds.
Thank goodness for that.
Honestly, yes. But it leaves the essential complexity entirely untouched.
Define essential complexity in this specific context.
Essential complexity is the conceptual mapping of software to the real-world problem it is trying to solve. It is user discovery. It is coordination across business units. It is managing the production blast radius of a change. Let's talk about discovery. Marty Kagan, one of the leading voices in product management, draws a hard line between feature teams and product teams.
Right. In his book inspired.
Exactly. Feature teams are just there to serve the business. Stakeholders hand them a roadmap, and the team's only job is output. The stakeholders take on all the risk of whether the feature is actually valuable or viable.
Which is exactly what an AI agent fleet excels at. Pure unadulterated output. You give it the spec, it gives you the feature.
Exactly. But an empowered product team is cross-functional. It's product design and engineering working together. Right. They are responsible for outcomes, not output. They are tasked with solving customer problems. And they have to tackle four distinct risks. Value risk, will users actually buy it or choose to use it? Usability risk, can they figure out how to use it?
Okay.
Feasibility risk, can we technically build it? And viability risk. Does this work for our business model, our legal constraints, our sales channels?
But wait, if I can iterate instantly with AI, doesn't that just solve the discovery problem?
How?
Because if I don't know what the user wants, I don't need a massive cross-functional team to debate it for a month. I just have my agent build three versions in 90 minutes. I show the user the generated app and I ask, is this right? I use the AI output as the discovery tool.
No, because iterating on the wrong premise just means you are digging a hole faster.
But I'm digging it for free.
But you're still in hole. LLMs do not solve value and viability risk. A coding agent cannot sit in a room with a frustrated user, read their body language when they get confused by a workflow, understand their unarticulated needs, and then negotiate a business model with your internal sales team.
That's true.
If a user says, I want a button to export everything to Excel, a feature team or an AI agent will just build the export button.
Right.
An empowered product team will ask, why are you exporting to Excel? Oh, you need to run a specific pivot table for your boss. Let's build that visualization natively so you never have to leave the app.
Okay, that's a fair point.
So you are saying pure speed without human led discovery is dangerous.
I'm saying it's fatal.
If we connect this to the bigger picture, building the wrong thing ten times faster directly violates agile principle number 10.
Simplicity, the art of maximizing the amount of work not done.
Exactly. If you use a fleet of agents to generate a massive, complex feature that nobody actually wants, you have maximized the amount of work done. And you have generated a massive maintenance burden for zero business value.
Okay, I hear you on the discovery piece. But what if the spec is validated?
What do you mean?
We do the human discovery. The PM and the engineer talk to the user. We figure out exactly what they need. We write the comprehensive spec kit markdown files, we approve the constitution, and then we generate. We separate the human discovery from the machine execution.
Then you run directly into the 10x speed waterfall trap.
The 10x speed waterfall trap. Okay, I love the sound of this, but explain it.
Heavy upfront specs risk recreating big design upfront or b doof.
Buduf.
Big design upfront is the absolute hallmark of the waterfall methodology that Agile was originally invented to destroy in the 1990s. You are just doing it on a faster timeline. Brigitte Vogler, an expert at ThoughtWorks, wrote a fantastic, highly detailed critique of spec-driven development tools like Kiro, Spec Kit, and Tesla.
What did she find?
She noted that for even a relatively small feature, these tools generate a staggering amount of markdown files that the human has to review before the code is generated.
The specification overhead.
Exactly. She used the German word versorung. Which means it means making something worse in a misguided attempt to make it better.
That's a great word. I love German words for incredibly specific problems, but why is writing specs making it worse? If I'm trying to control the AI, I need verbose specifications.
Writing 30 pages of markdown specs to control an AI? It's like trying to put a steering wheel on a bullet train.
A steering wheel on a bullet train.
You feel like you're in control because your hands are gripping a wheel, but the machine is on a track going 200 miles an hour and it is going to blast right past your guardrails anyway.
Okay. I see what you're saying.
Reviewing 30 pages of generated markdown specs is exhausting. Human brains are not built to parse raw, exhaustive technical specifications without losing focus. And worse, it creates a false sense of control.
Wait, why false? If it's in the spec, the agent follows it.
No, it doesn't. But I'll clarify that even with these elaborate perfect specs, the AI agents frequently just hallucinate past the instructions anyway.
But why? If the rule is explicitly written in the claw-progress.txt file, why does the LLM ignore it?
Because of how attention mechanisms work in transformer models. The LLM doesn't read the spec like a human referencing a rule book.
Right. It's all math.
Exactly. It calculates probabilities across the entire context window. If the agent is deep into writing a complex class, the local context of the code it just generated heavily outweighs the instructions from the spec 50 pages up in the context window.
Oh wow.
The AI might ignore the explicit rule about not creating duplicate classes and just reinvent the wheel, despite what the spec says. Because statistically, that's what the training data suggests comes next.
So the human thinks they've successfully constrained the AI with this heavy waterfall style design phase, but the AI just goes rogue at high speed during implementation?
Yes. And that leads directly to the next catastrophic failure mode. Black box code rot.
Code rot, but the AI just wrote it, it's brand new.
It doesn't matter how new it is if you don't know how it works.
Fair point.
If a developer uses a fleet of agents to generate a massive interconnected feature in an afternoon, and the human doesn't actually understand the underlying architecture the AI decided to use, the system becomes a fragile black box.
Because no one has the context.
Exactly. Internal maintainability rots away instantly. The mental model of a code base is the most valuable asset an engineering team has. In this scenario, that mental model resides entirely in the latent space of an LLM that forgets everything when the context window closes. It does not reside in the head of the human maintaining the system.
Well, wait, wait, wait. I have to stop you there. This is where I think you are clinging to nostalgia.
Nostalgia?
Yes. If the AI wrote it in five minutes, and two weeks later a user finds a bug and it breaks, who cares if I can't read it? I don't need a mental model.
How do you fix the bug?
I'll just have the AI rewrite the entire module in another five minutes. Why do I need to understand the syntax or the architecture if the agent can just regenerate the whole thing when a bug is found? You are applying a 2015 maintenance mindset to a 2026 reality.
I am not clinging to nostalgia.
Okay, convince me.
Because that assumption that the AI can effortlessly rewrite and fix a massive, broken black box system in five minutes without causing collateral damage is empirically false in the real world of 2024 through 2026.
False?
Yes. If you want to challenge true agility, if you think speed trumps feedback loops, let's move away from philosophy and thought experiments. Let's look at the hard empirical data.
Okay. Bring the data. I'm ready.
Let's start with the METR 2025 randomized controlled trial.
METR.
Model evaluation and threat research.
Yes.
And this wasn't a contrived benchmark where an AI solves a contained lead code puzzle in a sterile environment.
Right.
Metra recruited 16 highly experienced open source developers. These were maintainers of massive production grade repositories with over a million lines of code. They were paid $150 an hour to tackle real, complex issues in their own code bases.
Code bases they already understood deeply.
Exactly. And it was an RCT, a randomized control trial. So half the time they were assigned an issue they had to use AI to solve, and half the time they were forced to solve an issue without any AI assistance.
And when AI was allowed, they weren't using outdated models, right?
No. They used frontier tools, specifically Cursor Pro, powered by Claude 3.5 and 3.7 Sonnet. Now, before the study began, these expert developers were surveyed. They forecasted that using AI would speed up their pull request completion times by 24%.
Which tracks completely.
Everyone who uses these tools feels like AI makes them faster.
I use Claude every day, and I can say firsthand, it writes boilerplate in seconds.
Exactly. The perception of speed is intoxicating. The syntax appears on your screen like magic. But the objective reality?
What happened?
When these expert developers used AI tools to complete pull requests that actually met the strict, rigorous quality standards of their repositories. They took 19% longer than when they coded entirely without AI.
Wait. I need to stop you there.
It's shocking, I know.
Nineteen percent slower using Cursor and Claude 3.7. How is that physically possible? How could an expert developer possibly lose time using a tool that types a thousand times faster than them? Are we sure the RCT wasn't just giving them poorly optimized prompts?
It wasn't the prompting. It was the bottleneck of debugging and reviewing machine generated code. This goes back to black box code, Rob.
Okay, explain that dynamic.
The AI generates code instantly, yes. But the human cognitive load required to read, understand, verify, and debug that code is immense. Reading someone else's code is notoriously harder than writing your own.
And reading machine code that lacks human intuition is even harder.
Because the AI subtly breaks things.
Right.
The AI would generate a massive block of code that looked syntactically perfect. The tests might even pass locally, but it would subtly break an unspoken architectural rule in a million line code base.
Like what?
A race condition, a memory leak, a tight coupling between two modules that were supposed to remain separate.
And the developer has to catch that.
The developer then has to spend hours untangling the AI's logic, figuring out why it made the choices it made, and then manually fixing it or trying to coax the AI into fixing it.
Which takes way more time than just writing it correctly the first time yourself.
Exactly. Yeah, the perception gap was the most staggering part of the study.
Yeah.
Even after objectively taking 19% longer to get the pull request merged, the developers still self reported on the post study survey that they felt the AI had sped them up by 20%.
That is wild. They felt 20% faster while actually going 19% slower. It's like driving a sports car that sounds incredibly loud and aggressive, but the speedometer is broken, and you don't realize you're actually stuck in second gear.
It is the absolute illusion of speed. The syntax generation is so fast, it tricks the brain's reward center, blinding the developer to the hours they are burning on integration and debugging.
Wow.
And this isn't just an isolated study, by the way. This is backed up by GitClear's massive data report. GitClear analyzed literally billions of lines of code committed across the industry between 2023 and 2024.
And what did they find?
They found unprecedented spikes in code duplication and code churn.
Code churn meaning code that is written, committed, and then deleted or rewritten shortly after.
Yes. AI makes it incredibly easy to generate bad code quickly. Developers were accepting copilot suggestions, committing them, realizing they were flawed, and having to rewrite them.
So the sheer volume of code being produced was up, but the quality and durability were plummeting.
Precisely.
Okay, I hear the metadata and I hear GitClear. But what about the Dora reports?
Dora.
Dora, DevOps research and assessment, is the gold standard for measuring software delivery performance. Google runs this every year. Surely Dora found that AI improves delivery metrics. Every executive on the planet is pushing AI adoption to improve Dora metrics.
The 2024 and 2025 Dora reports are incredibly revealing. And they completely debunk the idea that AI alone makes you faster. It is an amplifier. It magnifies an organization's existing strengths, or it radically magnifies its existing chaos.
So if your organization is a mess, if your architecture is tangled, AI just makes it a faster, more tangled mess.
Exactly. Specifically, Dora found that AI adoption significantly inflates batch sizes.
Let's unpack batch sizes. Why is that bad?
A batch size is basically the amount of work, the number of lines of code in a single pull request. Because AI can write so much code so quickly, developers start submitting massive, monstrous pull requests.
Oh, I've seen this.
They asked the agent to build a whole feature, and the agent spits out a PR with 3,000 lines of changed code across 40 files.
Yeah.
And Dora has proven for a decade that large batch sizes destroy software delivery stability and throughput. Large PRs take longer to review, they have a higher rate of deployment failure, and they cause massive merge conflicts.
Unless you have mitigations in place.
Right. The DOR data explicitly shows that the negative impacts of AI on stability can only be mitigated by strict traditional agile engineering practices.
Lower case agility.
Yes. Specifically, teams that succeeded with AI were the ones working in very small batches, utilizing trunk-based development, and maintaining incredibly robust automated testing. If you don't have those fast feedback loops, AI just creates an avalanche of technical debt.
Because of cognitive load.
Yes. If we apply the principles from the book Team Topologies, we know that human brains and human teams have a strict cognitive load ceiling.
You can only hold so much in your head. Exactly.
Yeah. If you flood a developer with parallel 3,000 line pull requests that was you know generated by an agent fleet, you completely max out their cognitive load. They they can't review the code safely. They skim it, they stamp approved because they trust the AI, and basically that black box code rot makes it into production. So, what ends up happening?
Yeah.
Flow grinds to an absolute halt.
So what does this all mean? Let's take a breath here. Yeah. You've brought the data, and I have to concede. Defending lowercase agility, the fast feedback loops, the small batches, continuous integration, empowered product teams, it makes total empirical sense. The Dora data supports it, the Metter data supports it.
It's pretty undeniable.
But I have to turn this back on you. Tell me, how does any of that justify keeping bloated 2010 era scrum theater alive? Well. How does acknowledging human cognitive load justify a two-hour sprint planning meeting where we argue about Fibonacci numbers while the AI coding agent is sitting idle waiting for a ticket?
What's fascinating here is we are actually violently agreeing.
We are.
Yes. True agility, the agility Dave Thomas pleaded for in 2014, the agility that Dora actually measures in 2025 requires killing the theater.
Okay.
The bloated frameworks, the dark scrum, the endless certifications, they aren't agile. They are bureaucracy masquerading is agility. We have to strip it all away to survive the AI transition.
So let's synthesize this. Let's bring both sides of this debate together and look at what the most elite teams in the AI native era are actually doing to survive and thrive.
Good idea.
First, let's state definitively, for the record, what is officially dead in modern software engineering.
We can confidently retire the bloat. Story Point Theater is dead. You do not need to estimate the human typing time for a task that an LLM can generate in seconds.
Dead.
Massive, highly specialized, multi-developer scrum squads where handoffs happen between front end, back end and QA. Dead. The communication overhead is too high, and AI allows full stack execution by a single developer.
Dead. And infinite soul crushing backlogs. Also dead.
Thank goodness.
As the shape up methodology argues so well, backlogs are a massive psychological waste of time. Grooming hundreds of JIRA tickets that you will literally never get to gives managers a false sense of control, and it makes developers feel perpetually behind.
It really does.
If an idea is truly critical to your users, it will organically present itself during continuous user discovery. We move to six week bets, not infinite backlogs.
But while the theater dies, we are seeing the most successful teams, the ones topping the Dora charts, double down on core extreme agility practices.
Exactly. Door makes it clear.
We see this at extreme scale. Look at Google's massive monorepo. They have 35,000 developers working in a single massive trunk. They do not use long lived feature branches because integration pain grows exponentially with time and with batch size.
Right.
In an AI world, if an agent is generating thousands of lines of code, you must force the agent to integrate it in tiny human comprehensible slices.
Human comprehensible PR sizes are the ultimate bottleneck. If the PR is too big, the human reviewer's cognitive load maxes out, they skim it, they approve it blindly, and the black box code rot begins.
Which is exactly why executable, test-driven development and spec harnesses are thriving right now. You mentioned Anthropic's puppeteer MCP testing earlier.
Yes.
Simon Willison talks extensively about red-green TDD for agents. You don't just ask the agent to write a feature. You write a strict, failing test suite first, and the agent's only job is to make the test pass.
It's a constraint.
Yes. The test acts as a rigid executable boundary that prevents the agent from hallucinating, wandering off spec, or over-engineering the solution.
It's the ultimate combination. You use the AI to generate the accidental complexity, the syntax, the boilerplate, at near zero cost, but you use strict executable tests and tiny batch sizes to maintain human control over the essential complexity.
And that brings us to the ultimate truth of this entire series. We've journeyed from waterfall to scrummed DevOps to AI native. But what remains constant?
Direct user discovery.
Yes. Because AI makes the physical act of writing code near zero cost, the penalty for building the wrong thing has completely changed.
It has.
It used to be that building the wrong thing wasted six months of expensive developer payroll. Now it might only waste an afternoon of agent compute time. But the danger is actually higher.
Why?
Because if you deploy the wrong thing, you still alienate your users. You still clutter your product interface. You still incur the long-term maintenance burden of a bloated code base.
Building the wrong thing is the only true failure left. The syntax is free. The discovery is priceless. You need empowered product teams talking directly to users, deeply understanding the essential complexity of the business problem, and then and only then unleashing the AI to solve it.
Which leaves us with one final lingering concept to mull over. For everyone listening, whether you're a developer, a PM, or a director.
Yeah.
We've spent six episodes talking about the mechanics, the data, the frameworks, but there is a deeply human element to this transition that we haven't resolved.
Lay it on us. What's the final thought?
If the cost of generating code drops to zero, and our primary job on a daily basis becomes managing fleets of agents, reviewing their PRs, writing prompts, and refining markdown specifications. Will the next generation of engineers simply be code managers rather than code writers?
Whew. That's a heavy thought.
And if that happens, how do we preserve the fundamental human joy of creation? The flow state of actually building something with your own hands in a world where the machine types all the keystrokes.
That is the existential question right there. It brings us right back to that quantum computing lab. We've finally agreed to throw away the abacus, but we still have to figure out what it actually means to be the human standing in the lab, directing the machine.
The question for the next era.
Thank you all for joining us on this deep dive through the Ways of Working series. It's been an incredible journey. Until next time, keep your batches small and your discovery continuous.