Javier Castro

Posted on Aug 14

Agile Didn't Slow Down AI. Your Organization Did.

#ai #scrum

When AI agents start executing tasks rather than suggesting them, the sprint board doesn't break — the accountability structure does.

Picture a sprint planning session where half the backlog items are already "in progress" before the meeting starts. Not because a developer pulled them at midnight, but because an AI agent did — autonomously, correctly, and at a speed that makes your two-week sprint cadence feel like a scheduling quirk from the Eisenhower administration.

This is not a hypothetical. It's a pattern appearing across engineering organizations right now, and it's forcing a reckoning that goes much deeper than tooling. The question isn't whether agentic AI will change how software gets delivered. It already is. The question is whether your organizational structure — its accountability layers, its ceremonies, its career ladders — was ever actually built for speed, or just built to look like it was.

Here's the uncomfortable thesis: agentic AI isn't breaking Agile delivery. It's revealing that most delivery organizations were already the bottleneck.

From Autocomplete to Autonomous Teammate

The shift in kind matters here, not just degree.
AI agents are a new breed of systems that are semi- or fully autonomous, able to perceive, reason, and act on their own — and unlike chatbots that field questions and solve problems, they integrate with other software systems to complete tasks independently or with minimal human supervision.

That integration is the operational rupture point.
Executives have long relied on tidy categories: tools automate tasks, people make decisions, strategy determines how the two work together. That framing is no longer sufficient.

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. This tool-coworker duality breaks traditional management logic, which assumes technology either substitutes or complements — but not both simultaneously.

The adoption curve is steep.
Agentic AI usage is growing rapidly: active users have grown more than fivefold in the first half of 2026, with the sharpest increase occurring outside the initial audience of software developers.
Inside OpenAI itself, the pattern is starker still:
between December 2025 and April 2026, OpenAI moved from a pattern in which most functions primarily used conversational AI to one in which Codex was dominant across functions.
That's not gradual adoption. That's a flip.

The Sprint That Ate Itself

Here's where the organizational collision happens in practice. Scrum's architecture assumes work moves at roughly human velocity — that a developer writing code and a reviewer reading it are operating in the same cognitive time zone, more or less. Agentic systems have invalidated that assumption without anyone formally acknowledging it.

We're facing a crisis of the modern PR queue. If an AI agent can generate 500 lines of code in five seconds, but a human engineer still needs thirty minutes of deep focus to review those same 500 lines, the review queue becomes a catastrophic bottleneck. Human behavior adapts predictably — and destructively. Reviews degrade into rubber-stamping or pedantic nitpicking over style. Asynchronous wait times compound, killing continuous integration momentum and ballooning work-in-progress.

The telemetry backs this up.
When AI tools accelerate individual code generation without proportional acceleration of the review pipeline, a growing queue of unreviewed pull requests absorbs the productivity gains at the organizational level. Faros AI's 2025 telemetry study of over 10,000 developers across 1,255 teams found that 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%.
More damning:
organizational-level DORA metrics — deployment frequency, lead time, change failure rate — showed no measurable improvement despite the individual-level gains.

That last data point is worth sitting with. The agents are shipping. The organization is not.

What Actually Breaks

The delivery plumbing isn't the only casualty. The Scrum.org community — not exactly known for existential crisis — is openly grappling with what sprint planning even means when part of your team doesn't need sleep, doesn't attend standup, and runs out of budget rather than energy.
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's not a minor adjustment to a template. That's a different cognitive contract between a team and its work.

The sprint's internal economics shift too.
Tasks assigned to agents should be measured by compute cost, API token utilization, and human validation time required. A complex algorithm might take an AI agent three minutes to write, but 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.

The most critical operational risk in hybrid planning is the human-in-the-loop bottleneck. While an AI can generate 10,000 lines of code overnight, a human team might only have capacity to securely review 1,000. To maintain a sustainable pace, you must strictly limit agentic throughput to match your human code review capacity.

The implication nobody states plainly: the constraint in an agentic delivery pipeline isn't intelligence or execution capacity. It's human judgment, applied in real time to outputs generated faster than human judgment can reasonably operate.

The Accountability Gap That Process Cannot Fill

This is where the organizational collision gets genuinely uncomfortable.
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.

Thoughtworks put it directly:
clear accountability for the results of agents lies with the human team, and they must be able to monitor and make corrective actions. A central trust register could be maintained for all agents.
That sounds reasonable until you ask who, in a flat Agile team, is the designated accountability holder for an agent's 47 overnight commits.

Accountability requires human intent. Thoughtworks' Agentic Scope of Authority Framework mandates that every deployed agent must have a "designated principal" — a specific human executive legally and operationally accountable for the agent's outcomes.
The word "executive" is doing a lot of work in that sentence. Most delivery teams don't have a clear executive accountable for what a developer commits. Adding an agent to that ambiguity doesn't clarify things; it multiplies the surface area of the problem.

The roles being squeezed are exactly the ones that were already marginal.
Practitioners are exposed if their core value is running sprint planning, facilitating retrospectives, or maintaining Jira backlogs. Tools now automate or support much of this work.
If a playbook can capture it, software can replicate it.
The Scrum Master who spent three years making sure standup started on time isn't threatened by AI in the abstract. They're threatened by the specific fact that their job description describes a coordination problem — and coordination problems are exactly what agents are good at.

The Fair Counterargument

None of this means Agile is dead. The people arguing it is are usually solving for a narrower problem than they claim.

Forrester's 2025 State of Agile Development report presents a striking counterpoint: 95% of professionals affirm Agile's critical relevance to their operations, with 61% reporting deployment of agile practices for over five years.
The principles of short feedback loops, working software over documentation, and responding to change over following a plan remain sound even when the agent executing the sprint task is a language model.

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.
That's not a marginal improvement. That's what Agile was supposed to enable, finally freed from the friction of manual information synthesis.

There's also Thoughtworks' cybernetics framing, which is quietly one of the more useful mental models circulating right now:
leading an agentic SDLC presents similar challenges to managing an organization. If we want to lead agents effectively, we must take on a new steering role in the SDLC and stop trying to review every line of code.
In more predictable areas, the role of humans is evolving from "human-in-the-loop" to "human-on-the-loop." Humans will look after agentic workflow performance and reliability rather than reviewing every single change.
That's a genuine upgrade to the job, not a demotion — for the people positioned to take it.

What Has to Change

With AI largely taking over coding tasks, the developer job profile must evolve, requiring substantial upskilling of current staff. Experienced engineers will move into roles focused on architecture, orchestration, and governance. New roles will emerge to develop and maintain the agentic platform — knowledge architects, agentic architects, agent reliability engineers. The focus of team capabilities is shifting from coding to code review, prioritization, and auditing.

How teams collaborate and structure themselves will need to evolve as we better understand what is possible with agentic systems. Agent topologies may need to sit alongside team topologies, and feedback cycles rethought accordingly.

Governance needs to be embedded in the workflow, not layered on top afterward.
Technical control mechanisms embedded in the development and operations environment are essential. Governance becomes part of the workflow rather than a separate overlay.
This is the part organizations routinely get wrong: they treat compliance as a post-delivery conversation, then discover an agent committed something that violated a data boundary at 2 a.m., and nobody owns it.

The honest read is that agentic AI is performing a kind of organizational audit that no consultant was ever empowered to do. It moves at a speed that makes the gap between stated process and actual capability impossible to ignore. The teams discovering that their sprint velocity was always constrained by coordination theater — not by developer skill — are the ones who will adapt fastest. The ones insisting that the problem is the AI, not the org chart, will spend 2027 writing post-mortems.

The sprint board doesn't care who filled the tickets. The production incident absolutely does.

AI amplifies what you bring: bring expertise, judgment, and the ability to handle human complexity, and AI makes you more effective. Bring only mechanical competence, and AI shows you were always replaceable.
That's not a threat. It's just the bill coming due.

DEV Community