The Merchants of Complexity: Why AI Finally Delivers What Agile Promised
The era of scarcity is over. Why paying the "Agile Tax" in a world of verifiable code is financial negligence.
Agile is dead.
I posted this on LinkedIn yesterday, and the reaction was intense. Over 150 comments later, the thread became a perfect case study in what I call “process Stockholm Syndrome.”
The critique wasn’t straightforward. It was a mix of denial and semantics. “That is not real Agile.” “You are confusing the Manifesto with Scrum.” “You just implemented it wrong.”
Let’s get the semantic defence out of the way early. I know the difference between the philosophy (Agile) and the framework (Scrum/SAFe). But I am looking at Applied Agile: the version 99% of companies actually buy and practice. The version that sells certifications and fills calendars.
Here is my real argument: the Agile Manifesto was right. Working software over documentation. Responding to change. Collaboration over negotiation. These are the right values. The problem is that the ceremonies we built to achieve them became the very obstacles standing in the way.
AI doesn’t kill the Agile vision. It finally makes it possible.
In the last 12 months, AI has collapsed the cost of producing and verifying code. I don’t mean it is “near zero” in some abstract sense. I mean that for the teams I work with, the time it takes to go from “Idea” to “Working, Tested Prototype” has shrunk from weeks to hours. We are not just generating faster. We are verifying faster. Tests, evals, automated gates. The entire feedback loop that Agile was trying to create through human rituals can now run in minutes.
The wolf has been cried for years. I am just pointing out that the wolf is finally actually here.
I am not writing this as a theorist or a consultant selling a certification. I am writing this as a builder turned Operating Principal. I spent 25 years in the trenches. Shipping products. Building ventures. Now I look at the P&L of portfolio companies and help them implement AI strategies that actually move the needle. I have onboarded hundreds of developers onto AI workflows and shipped mission-critical platforms in regulated industries.
And here is what I see. The teams with the most “Agile Maturity” are often the slowest shippers.
The Math of the “Agile Tax”
Let’s look at the hard data.
According to reports from Retool and Clockwise, the average developer spends less than 40% of their time actually writing code. The other 60% is consumed by “overhead”: meetings, status updates, waiting on tickets, and other rituals.
In a pre-AI world, we accepted this tax as the cost of coordination.
But recent data from GitHub shows that AI-assisted developers code 55% faster. McKinsey’s analysis backs this up, showing productivity gains of up to 2x for documentation and code generation tasks.
But here is the reality that matters.
It is not just about raw speed. It is about Process Design. If you take a tool that makes you 300% faster but you don’t redesign your stream to take advantage of it, you are lighting money on fire.
You are generating code at the speed of AI, but reviewing and deploying it at the speed of 2015. The bottleneck shifts from “Writing” to “Processing,” and your expensive new AI tools sit idling in the driveway.
The Cultural Debt Gap: Startups vs. Enterprise
We see this divide most starkly when comparing AI-native startups to legacy enterprises.
A scrappy startup founded in 2025 doesn’t have “Cultural Debt.” They don’t have 10 years of habits revolving around 2-week sprints, story points, and Jira grooming sessions.
The Startup uses AI agents to architect, code, and test in a continuous stream. They treat AI as a collaborator, not a tool.
The Enterprise buys GitHub Copilot licenses but forces developers to use them inside the same rigid Scrum ceremonies they used in 2019.
Now, let me be fair. Enterprises have legitimate complexity that startups don’t face: compliance requirements, integration with legacy systems, and coordination at scale. These are real constraints, not excuses.
But let’s also be honest. A lot of what hides behind “compliance” and “scale” is actually layers of process theatre and middle management that exists to manage the process rather than deliver outcomes. I have seen enterprises at scale that run lean and fast. They prove it is possible. The ones that don’t are making a choice.
The economic difference is brutal. The startup operates with a 10x efficiency multiplier because their process matches their tools. The enterprise sees a 10% efficiency gain because their process is actively fighting their tools.
The Shift: From Stories to Specs
The most damning evidence isn’t just speed. It is structure.
McKinsey’s recent research on “Software X” highlights a critical divergence. Companies sticking to traditional workflows see marginal gains of around 10%. Companies that change the workflow see exponential gains. (You can watch the full breakdown of their findings here: McKinsey “Software X” Report Discussion).
The key shift? Moving from “Story-Driven” to “Spec-Driven” Development.
Agile is built on User Stories, which are tiny and fragmented tickets designed to fit a human’s limited cognitive load. AI has the opposite profile. It has a massive context window. It doesn’t get overwhelmed by complexity. It craves context.
Old World: The Product Manager fragments the vision into 50 Jira tickets. The developer picks them up one by one and often loses the big picture.
AI World: The Engineer writes a holistic Spec. The AI holds the entire architecture in its context and implements it.
Agile optimizes for the fragments. AI optimises for the whole.
The Solution: The AI-Native Stream
So, if not the ceremonies, then what?
We need to stop trying to fit the jet engine onto the bicycle. We need a new chassis.
Rethink the Team Unit: The “Squad” of 8-10 people is built for a world where humans do all the execution. The communication overhead kills velocity. The new execution unit is 1 Senior Engineer + AI. McKinsey calls them “One Pizza Pods.” I call them Code Conductors.
But let me be clear about what this replaces and what it doesn’t. Domain experts still feed the system with their knowledge. Product thinkers still shape the vision. Stakeholders still review and redirect. The collaboration doesn’t disappear. The ceremony tax does. The domain expert can look at a working prototype anytime and give feedback. They just don’t need to sit through a two-hour refinement session to do it.
Junior developers don’t vanish either. But their growth path changes. Instead of learning by writing boilerplate, they learn by reviewing AI output, understanding architecture, and developing judgment. The skill becomes curation and verification, not just generation.
Rethink the Cadence: Sprints are artificial batches. Waiting two weeks to “demo” work that took 4 hours to generate is insanity. Move to Streams: continuous flow with no start or end dates.
Verification-First Development: This is the critical shift. We don’t just use AI to write code faster. We use it to write the verification layer first: tests, evals, automated gates. The AI checks its own work against deterministic guardrails. The human moves from being the Bricklayer to the Site Inspector.
This is how you avoid the “fast technical debt” problem. Code generated quickly is only dangerous if it is unverified. With proper context engineering and automated quality gates, you can move fast and maintain architectural coherence. The discipline shifts from “slow down to avoid mistakes” to “build the verification system that catches mistakes at speed.”
De-risking via Code, Not Meetings
The final defence of the Agile crowd is always: “But we need meetings to align and de-risk!”
This is the Coordination Gap. And they are right. It is the hardest problem to solve.
But Agile attempts to solve coordination through abstraction: debating requirements, estimating points, and arguing over words.
AI solves coordination through demonstration.
In an AI-native workflow, the cheapest way to de-risk a feature is not to hold a “Refinement Session.” It is to build the prototype.
If I can generate a working, interactive version of the feature in 2 hours, I don’t need a meeting to speculate on whether it will work. I can show you. “Show, don’t tell” creates alignment 10x faster than “Ticket and Discuss.”
This is what the Agile Manifesto actually wanted. Working software as the primary measure of progress. We just finally have the tools to deliver it.
Removing Cultural Debt
The technology is ready. The bottleneck is now Cultural Debt.
Cultural Debt is the scar tissue of old processes. It is the Senior Engineer who insists on “Planning Poker” because they are traumatised by a failed project in 2015. It is the Manager who feels unsafe if they don’t see a burn-down chart.
To pay down this debt, we must be clear-eyed:
Stop rewarding effort (Story Points). Reward shipped outcomes.
Audit your roles honestly. If someone’s primary job is moving cards from column A to column B, that function is being automated. Redeploy that talent toward work that creates value.
Audit the latency. Look at your cycle time. If your coding time is in minutes but your shipping time is in weeks, your process is the problem.
The Promise, Finally Delivered
We are moving from a world of scarcity to a world of abundance. For twenty years, code was expensive, so we built a religion around managing it carefully. The ceremonies were well-intentioned. They were the best we had.
Now code is fast to generate and fast to verify. The companies that win will be the ones that redesign their streams to match this reality.
The Agile Manifesto had the right values. Responding to change. Working software. Collaboration. The ceremonies we built betrayed those values by adding friction in the name of control.
AI doesn’t kill Agile. It finally makes it possible.
I will be continuing this series by looking at the hard numbers. In future posts, I will share the specific playbooks, methods, and results from companies where I have introduced this AI-native stream with my paying subscribers.