Javier Castro

Posted on Aug 26

Agile Didn't Prepare You for an Agent That Just Merged to Main

#theaiorganizationcollisio

When AI stops suggesting and starts shipping, the org chart becomes the bottleneck — not the backlog.

Picture this: a pull request lands in your repository at 2:47 a.m. It touches fourteen files across three services, passes every automated test, and was authored by no human being alive. By 9 a.m., the change is in production. Nobody signed off on it. Nobody was asked to. The sprint board wasn't updated. The standup, scheduled for 10, will discuss it after the fact — if anyone notices.

This is not a thought experiment.
StrongDM's three-engineer team, operating as of mid-2025, built a system where no human reviewed the code that produced a given output, no human wrote the tests that validated it, and no human built the replica environment against which it was tested.

The humans designed the system that designed the system.
That sentence, understated as it is, describes a genuine rupture in how accountability has worked in software delivery for the past two decades.

Here is the uncomfortable claim worth making: Agile didn't fail when agentic AI showed up. Agile revealed what it was always hiding — that most of its ceremonies are accountability proxies, not coordination tools. When an AI agent can execute tasks without human involvement, those proxies evaporate. What's left is either real governance or a ritual performed for nobody.

From Assisting to Acting

The distinction matters more than the industry has admitted.
Agentic AI is a fundamentally different class of system — semi- or fully autonomous, able to perceive, reason, and act — and unlike familiar chatbots, it integrates with other software to complete tasks independently or with minimal human supervision.

That shift from "minimal human supervision" to "no human in the loop" is not incremental.
Executives have long relied on a tidy tripartite frame: tools automate tasks, people make decisions, strategy governs both. That frame no longer holds.

Between December 2025 and April 2026, OpenAI moved from a pattern in which most functions primarily used conversational AI to one in which Codex — its agentic coding platform — was dominant across functions.
And this wasn't confined to engineers writing code: Codex's share of output tokens rose across the seniority distribution, meaning agentic tooling is used by both junior and senior workers. It is not only a tool for direct implementation — senior users also rely on it for planning, review, and delegating tasks and evaluating outputs.

When senior staff are delegating to agents, the question of who owns a decision is no longer rhetorical.

The Accountability Vacuum

Agile's ceremonies — standup, sprint review, retrospective — exist partly to establish shared situational awareness and, more subtly, to create distributed accountability. Everyone knows who picked up the story. Everyone knows why the estimate slipped. The social fabric of the sprint creates a diffuse but real sense of ownership.

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 dismantled faster than organizations replace it.

And it is being dismantled. Building AI agents is often a cross-team effort, and in one recent study, participants described limited ownership over risks tied to components built by external teams or falling outside their perceived responsibility. One practitioner quoted in that same research drew a clear line: they were "the tech guy," responsible only for reproducibility, with regulatory and organizational accountability framed explicitly as "not really my concern."
This externalization of responsibility echoes prior responsible AI work showing that practitioners often distribute ethical accountability across sociotechnical networks until it belongs to no one in particular.

The sprint board doesn't capture what the agent did last night. The retrospective can't surface a decision nobody made.
While recent research has focused mainly on the capabilities and productivity impacts of these systems, much less attention has been paid to accountability: who is responsible when agents generate, modify, or recommend code?
The Terms of Service documents that govern tools like GitHub Copilot and Claude Code answer that question in ways most engineering managers have not read carefully.

Accountability in software has historically worked through product liability, professional licensing, and contractual warranties. None of these contemplate software that no human has reviewed.

The Process Model Can't Keep Up

The Agile Manifesto's authors wrote for a world where the expensive variable was human attention, and the scarce resource was working software.
Capgemini's Steve Jones has argued that AI agents building apps in hours have killed the Agile Manifesto, as its human-centric principles don't fit agentic software development lifecycles.

Forrester pushes back: a 2025 State of Agile report found 95% of professionals still affirm Agile's critical relevance, with 61% reporting deployment of Agile practices for over five years.

Both data points can be true simultaneously. Organizations say Agile is relevant in the same breath they announce plans to automate sprints. Casey West has proposed an Agentic Manifesto adapting Agile values for autonomous systems, shifting the emphasis from "verification" — did the system do what I said — to "validation" — did it do what I actually wanted.
That is a profound semantic shift dressed in mild language. Verification is a process discipline. Validation requires human judgment. You can automate the former; the latter requires someone to show up.

Multiple organizations are experimenting with "Agentic Delivery Lifecycles" that wrap traditional SDLC practices with new governance models for non-deterministic AI behavior. AWS, in its 2026 prescriptive guidance, has suggested that sprint planning must evolve into "Intent Design," where architecture becomes scaffolding — defining roles, guardrails, and fallback mechanisms rather than scripting every decision path.

That's a reasonable adaptation. But "Intent Design" still requires someone who can articulate intent precisely enough that an agent doesn't hallucinate the product roadmap.

The Human-on-the-Loop Problem

ThoughtWorks, in research published in early 2026, offers an instructive framework.
In more predictable areas, the role of humans is evolving from "human-in-the-loop" to "human-on-the-loop" — monitoring agentic workflow performance and reliability rather than reviewing every single change.

The distinction is real and useful. But it carries a hidden organizational cost. Human-in-the-loop is operationally expensive and cognitively taxing. Human-on-the-loop requires something harder: sustained, high-quality attention over low-frequency but high-stakes events. Most teams aren't structured to provide that. The on-call engineer who used to own the pager now owns something far more diffuse — the ongoing judgment of whether the agents are drifting in the right direction.

AI agents introduce complexity to operational structures, requiring governance and steering that doesn't appear automatically. In practice, research on deploying AI agents found that 80% of the work was consumed by unglamorous tasks associated with data engineering, stakeholder alignment, governance, and workflow integration — not by prompt engineering or model tuning.

Eighty percent on the organizational plumbing. The people who approved the agent pilot probably weren't told that.

What Genuinely Changes (And What Doesn't)

The counterargument deserves an honest airing.
A carefully reconstructed industrial record from a longitudinal field study showed that progressively more orchestrated human-AI delivery configurations were associated with markedly shorter delivery times, lower downstream issue load, higher first-release coverage, and lower modeled staffing burden.
The strongest results arrived only after the workflow became acceptance-criteria-aware, repository-native, and review-aware — a pattern more consistent with an orchestration thesis than with a "better autocomplete" thesis.

That matters. The gains are real when the governance is real. The problem is that most organizations deploy the agent before building the governance, then wonder why the productivity curves flatten after the initial spike.

Many organizations continue to operate under the assumption that engineering capacity is the primary constraint — a belief rooted in decades of conventional software development, where progress was largely determined by the availability of skilled developers. In the context of agentic AI, that assumption no longer holds.

The bottleneck isn't engineers. It's the clarity of intent, the quality of acceptance criteria, and the organizational maturity to distinguish between an agent that shipped working code and an agent that shipped code that works today.

The non-determinism of LLMs — the foundation on which AI agents are built — requires governance implemented through policy-as-code rules, not through a retrospective on Friday afternoon.

The Real Org Chart Collision

Teams adopting agentic delivery are discovering that the collision isn't between AI and engineers. It's between autonomous execution and the org chart's existing conception of ownership.
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 — breaking down traditional management logic, which assumes technology either substitutes or complements, but not both simultaneously.

Role profiles change under agentic delivery. Implementation remains important but is increasingly complemented by AI engineering, platform operations, knowledge management, and governance. Technical system understanding, security competence, and the ability to evaluate AI-generated artifacts all gain in importance.

The sprint isn't dead. But the sprint's implicit theory — that a two-week cycle of human decisions creates accountability through rhythm — is cracking under a system that executes in minutes and doesn't wait for standup.

The organizations that will get through this are not the ones moving fastest to autonomous delivery. They're the ones that noticed their Agile ceremonies were doing double duty all along: coordinating work and enforcing accountability. When an agent takes over the first job, someone has to consciously rebuild the second. That someone probably isn't on the sprint board. They might not have a title yet. And they will be, without irony, the most important hire of the next three years — right up until someone trains an agent to replace them too.

DEV Community