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 to this Explainer Series overview. We're going to cut straight through the hype and look at how the last 55 years of software engineering have essentially been one single unified quest to shrink the feedback loop.
Let's dive right into our agenda. We've got shrinking the feedback loop, textbook ideals versus team pathologies, the immutable laws of complexity, data over developer dogma, and finally the series roadmap.
Let's get into it. Section one, shrinking the feedback loop. The 55-year quest for speed. So the big picture here is an ongoing effort to compress the time between having an idea and actually getting working software into users' hands.
We've moved from Winston Royce's early multi-year waterfall models back in 1970 right through to today's lightning fast AI agent loops. Whether it was the Agile Shift in 2001, demanding working iterations, the DevOps movement of the 2010s automating continuous delivery, or this new dawn of AI assisted coding, the ultimate goal has always been exactly the same.
We are constantly trying to shrink that feedback loop to figure out if what we're building actually works. Compiling is just automated construction. This means that all human programming effort is actually a highly variable creative design process, and that completely resists rigid planning.
Think about it if building a bridge is traditional engineering, software development is entirely different. Because compiling code costs essentially nothing, the entirety of a developer's effort is spent on design.
And because it's a creative process, it just can't be perfectly predicted or mapped out on some rigid multi year Gantt chart. This fundamental truth is exactly why iterative feedback loops were born in the first place.
Section 2. Textbook ideals versus team pathologies, theory versus the trenches. Now, while we aim for these pristine ideals like agile iterations and continuous delivery, bureaucratic pathologies almost always warp them.
I'm sure you've seen this in your own work, right? A framework is introduced to increase flow, but human nature and organizational politics quickly distort it into something else entirely. Agile becomes a micromanagement tool focused on gaming story point KPIs, basically just Jira ticket moving theatre.
Continuous delivery gets bottlenecked by long-lived Git flow branches waiting weeks for a human to review them. We are just remarkably good at finding ways to slow ourselves down. And you know, this friction is absolutely still true today with AI, where we're seeing developers swap rigorous review for unverified vibe coding.
This is a really dangerous modern pathology that inflates PR batch sizes rather than utilising strict agentic engineering patterns. As Simon Willison warns, generating code is incredibly cheap now, but good code still has a cost.
If we just use AI to dump massive amounts of unreviewed, complex code onto our collaborators through vibe coding, we're actually destroying the feedback loop. True agentic engineering means we have to build entirely new habits to prevent our teams from drowning in technical debt.
Section three. The immutable laws of complexity. Why methodologies fail. Why do these robust frameworks inevitably drift into chaos?
Well, as Mel Conway pointed out back in 1968, the structure of any system will inevitably mirror the communication structure of the organization that built it. Meaning our team topologies dictate our software architecture. This is a remarkable, almost inescapable law of software.
If you have four distinct teams working on a compiler, you'll get a four-pass compiler. You literally cannot separate the technical architecture of your software from the human communication pathways of your engineering teams.
In short, you simply cannot out-architect your own organizational chart. And when we look at this through Fred Brooks' lens of complexity, we realize that while modern AI absolutely slashes the accidental cost of boilerplate syntax and routine testing, it leaves the essential complexities of domain rules and organizational boundaries entirely intact.
AI is brilliant at remembering programming syntax, but it can't automatically resolve a conflicting business rule, nor can it negotiate an API contract between two siloed departments. The essential complexity of human cognitive load remains our biggest bottleneck, no matter how good the AI gets.
Section 4. Data over developer dogma. Empirical guardrails for the series. Okay, let's look at the actual empirical data, rather than relying on practitioner opinions and hype.
Shockingly, METR's randomized control trial proved that early 2025 AI tools actually slowed down experienced open source developers by 19% on complex tasks. That directly contradicts popular dogma. The developers in the study subjectively felt like the AI was speeding them up, they estimated a 20% gain, but the rigorous timing data proved the exact opposite.
This highlights a massive gap between perception and reality when adopting new ways of working, proving for sure that we can't just rely on anecdotes. Furthermore, the 2024 Dora report found that while AI adoption significantly increases individual job satisfaction and flow, it introduces some pretty unexpected trade offs by actually hurting overall software delivery stability.
Across thousands of professionals, Dora found that integrating AI led to a lower overall delivery throughput. Why? Because teams forgot the fundamentals.
AI allowed them to generate larger batches of code, which then broke the build. It proves that new tools demand a renewed focus on the absolute basics, like small batch sizes and robust testing. This is exactly why we have to stay grounded in Dora's four core performance metrics throughout this series change lead time, deployment frequency, change fail percentage, and failed deployment recovery time.
They are basically the ultimate lie detector test for any methodology, ensuring we're actually shrinking the feedback loop without sacrificing quality. These metrics reveal the truth. If a new framework or AI tool doesn't improve these numbers, well, it's just adding noise.
Section 5. The series roadmap. Mapping our six-part journey. So let's map out exactly how we're going to explore all of this.
We'll trace the journey from Agile's origins in episode 1 all the way to spec-driven AI workflows and our grand finale debate in episode 6. Along the way, we're gonna look at how teams actually implement Scrum and Kanban versus the pristine theory, how to effectively manage workflow instead of getting bogged down in estimation theatre, and what a truly AI native workflow looks like when we rely on strict specifications.
I'll leave you with this final rather provocative thought before you join us for episode one. As our tools get infinitely faster, are we truly shrinking the feedback loop or just finding faster ways to automate our existing organizational dysfunctions?
It's a massive question, and I absolutely can't wait to unpack it with you in the next explainer. See you there.