Javier Castro

Posted on Aug 21

The Sprint Isn't Broken. Your Process Is Just Finally Visible.

#theaiorganizationcollisio

Agentic AI doesn't destroy Agile delivery — it stress-tests the organizational scaffolding that Agile was always supposed to replace.

A senior engineer opens her pull request queue on a Monday morning and finds 47 open PRs. Some are two days old. Some are from an AI agent that ran overnight and churned through the kind of repetitive API integration work that used to chew up three developer-days per sprint. The code looks plausible. The tests pass. Nobody has reviewed any of it yet, and the sprint ends Thursday.

This is not a hypothetical anymore. It is happening right now in organizations that adopted agentic tooling faster than they rewired the process around it. And it exposes something the industry has been carefully not talking about: the bottleneck in software delivery was never writing code. It was everything else — the coordination, the judgment, the organizational scar tissue that Agile frameworks were supposed to dissolve but mostly just formalized.

Agentic AI didn't break software delivery. It just made already-broken delivery processes impossible to ignore.

The New Constraint Nobody Planned For

Agentic AI marks a fundamental shift in how autonomous systems reason, plan, and execute multi-step tasks. Not as marketing copy — as a structural fact. A new breed of semi- or fully autonomous AI systems integrates with other software to complete tasks independently or with minimal human supervision, which means that for the first time, the generation side of the delivery pipeline has become genuinely elastic. You can throw more agents at a problem and get more code. At speed.

The catch is immediate and brutal: if an AI agent can generate 500 lines of code in five seconds, but a human engineer still requires thirty minutes of deep cognitive focus to thoroughly review those same 500 lines, the review queue becomes a catastrophic bottleneck.

As agentic systems embed themselves into development workflows, they generate more code and submit more pull requests than any human team used to. The capacity of human reviewers has not scaled at the same pace. Code generation is increasingly automated; ensuring the quality of that code still relies heavily on manual inspection. The math does not work in anyone's favor.

A 2025 telemetry study of over 10,000 developers across more than 1,200 teams quantified this precisely. Teams with high AI adoption completed 21% more tasks and merged 98% more pull requests, but PR review time increased by 91%, average PR size grew by 154%, and bug counts rose by 9%. Organizational-level DORA metrics — deployment frequency, lead time, change failure rate — showed no measurable improvement despite the individual-level gains.

Read that again. Individual throughput goes up. Delivery performance stays flat. Bugs climb. This is not a technology problem. It is a process architecture problem that the technology made visible.

What the Sprint Was Always Hiding

AI coding tools have measurably raised individual developer output. The resulting velocity gains at the project level have been surprisingly modest — because coding was never the real bottleneck. The bottleneck has shifted upstream to specification and verification, areas that require human judgment. This carries significant implications for how engineering teams should be structured.

Agile practitioners have heard this for fifteen years. The theory was always that you break work into small, testable increments, keep feedback loops tight, and stay adaptive. Fine. But what many organizations actually built was a ceremony-laden coordination overhead machine with a two-week time-box bolted on top of a waterfall mindset. Standups that replaced actual conversation. Backlogs that nobody trusted. Retrospectives where the same three impediments got politely noted and nothing changed. Every sprint, like clockwork.

Agentic SDLCs are causing a fundamental break with Agile principles because they are simply too fast for Agile. The traditional two-week sprint cycle looks antiquated when AI can generate functional code in minutes. This is the sharp observation Capgemini's Steve Jones made in early 2026 when he argued publicly that agentic systems had killed the Agile Manifesto — and the debate that followed was instructive. Not because Jones was entirely right, but because the reaction revealed how much of "Agile" had calcified into exactly the kind of procedural orthodoxy the 2001 manifesto was supposed to prevent.

As analyst Eric Newcomer observed in the ensuing discussion: "I don't know, I can agree we need a new manifesto all right but I think bureaucracy killed agile before AI agents came along." That's the sharper diagnosis. Agentic AI is arriving into delivery organizations that already had serious problems with specification quality, review culture, and governance clarity. It's just making those problems sprint-by-sprint obvious instead of quarter-by-quarter deniable.

The Ceremony That Can't Be Automated Turns Out to Matter Most

Here's what the productivity numbers keep missing: a core risk emerges when AI not only handles individual tasks but also orchestrates the entire workflow — the established process, which serves as a harness for ensuring quality, could be at risk.

In an AI-augmented sprint planning session, the format of the work changes. You no longer assign agents standard user stories formatted as "As a user, I want...". Instead, the product backlog item must be translated into a technical system prompt. That sounds like a trivial formatting change. It isn't. A ticket is only "Ready" for an agent if the prompt contains zero ambiguity — if the prompt is not technically sound, the agent will fail, and it will do so with impressive confidence. Writing that prompt is a different cognitive task than grooming a backlog item for a developer who can ask follow-up questions in a standup.

The work of making intent precise, testable, and unambiguous doesn't disappear when you introduce agents. It intensifies. Large-scale agile frameworks remain largely human-centric, relying on coordination meetings, artifact synchronization, and role-based handoffs that inhibit real-time adaptation. Meanwhile, the organizations pulling ahead aren't the ones who bought the best agentic tooling. They're the ones who invested in the unglamorous upstream work: requirements precision, acceptance criteria rigor, and governance by design rather than governance by policy memo.

Research from MIT Sloan found that the biggest challenge in deploying AI agents wasn't prompt engineering or model fine-tuning — 80% of the work was consumed by unglamorous tasks: data engineering, stakeholder alignment, governance, and workflow integration.

Eighty percent. The stuff that looks like overhead on a velocity dashboard.

The Fair Counterargument

The objection that Agile is more adaptive than its critics give it credit for deserves a serious hearing. Rolf Läderach, head of operational excellence and Agile coach at Sandvik, countered that Agile is not the Manifesto, and is certainly not about frameworks — and he's right that the underlying principles (short cycles, continuous feedback, adaptive planning) are arguably more relevant, not less, when your execution layer runs at machine speed.

In consulting practice across European enterprises, Product Owners and Product Managers are using AI to complete discovery cycles several times faster — but only when they already know which questions to ask. Retrospectives that draw on AI-identified patterns across multiple sprints surface systemic impediments that manual review often misses.

There's a version of this that works well. In more predictable areas, the role of humans is evolving from "human-in-the-loop" to "human-on-the-loop" — humans monitor the agentic workflow's performance and reliability rather than reviewing every single change. That's a mature, considered model. It's also the model that requires the org to have done the hard structural work first.

Practitioners whose core value is running sprint planning, facilitating retrospectives, or maintaining Jira backlogs are exposed. Tools now automate or support much of that work. But the flip side is equally true: practitioners who were doing genuine organizational diagnosis, managing the politics of technical debt, and translating business risk into engineering constraint are not more redundant. They're more necessary, and more obviously so, than at any point in the last decade.

The Organizational Rewiring Nobody Budgeted For

For strategists, agentic AI's dual nature as both tool and coworker creates new dilemmas. A single agent might take over a routine step, support a human expert with analysis, and collaborate across workflows in ways that shift decision-making authority simultaneously. This tool-coworker duality breaks down traditional management logic, which assumes that technology either substitutes or complements — but not both, and not all at once.

That's the structural tension that Agile ceremonies weren't designed to handle, because the ceremonies were designed for human teams. Tasks assigned to agents should be measured by their compute cost, API token utilization, and — most importantly — the human validation time required. A complex algorithm might take an AI agent three minutes to write, but it might take a human architect three hours to securely review and merge. Plan your sprint purely on the AI's generation speed and you will create a massive, unmanageable bottleneck at the human review stage.

AI agents introduce complexity to operational structures, requiring enhanced governance and steering to prevent organizational chaos — especially given the speed of AI development and the volume of generated code. Governance, in this context, isn't a compliance checkbox. It's the actual load-bearing structure of delivery. Governance becomes part of the workflow rather than a separate overlay.

Teams that treat governance as an afterthought — something the compliance team handles in a parallel track — will find that their agentic velocity gains evaporate exactly where it matters: at the point of merge, at the point of release, and eventually, at the point of incident.

The Question Worth Sitting With

The honest reading of where the industry sits in mid-2026: agentic AI is genuinely accelerating individual and task-level output. The organizational layer — the structures, accountabilities, and review culture that sit around that output — has not kept pace. The gap between machine production velocity and human organizational bandwidth is widening, not closing.

Humans shaping software development remain necessary because a human is accountable for the output. We need humans with skin in the game to ensure that the intent given to agents is actually fulfilled. But if we insist on being the "human-in-the-loop" for every single code change, we will become more than just a bottleneck — we'll become a fracture point.

The organizations that navigate this well won't be the ones that figured out the right prompting strategy for their agents. They'll be the ones that looked honestly at their delivery process — at what the sprint ceremony was actually hiding, at what the review culture was actually enforcing, at what the Scrum Master was actually doing — and rebuilt it around the new constraint structure. Less ceremony, more specification. Less velocity theater, more accountability architecture.

The sprint isn't broken. But if you're honest, it was already showing cracks before the agents arrived. They just turned the lights on.

DEV Community