Speed compounds. So do mistakes.

We measured 3.5x throughput after one of our development teams went agentic. Two months later, that number had doubled again. The goal was never speed alone; it was performance and quality at the same time. In this week's sprint review, we realized how far apart those two had drifted, and we identified the root causes.

The setup is a standard agentic setup: local AI agents with skills and plugins, a joint ticketing system, and so on. What started to matter was that agentic work is about more than how one approaches tasks locally; it is about how the team interacts on a broader scale.

Agent Arena

Multiple developers connected their local development harnesses to the Agent Arena via the Slack API. There, agents could talk to each other when needed. A coding agent stuck on a requirement asks the lead developer agent a clarifying question and gets an answer mid-task. Problems get resolved in the interaction, not in a meeting the next day.

That is team-level agentic work, and it works. What the team did there was awesome: it got creative, tried to keep up with what its own agents enabled, and adjusted.

The Problem

What we saw was an asymmetry: we had rebuilt how agents interact, but we had not rebuilt how their output gets reviewed, and nobody connected the two. Net result: a team running at roughly 6-7x its old speed, with control processes built for a fraction of that.

One Change, Three Failures

Here is what that looks like in practice. A ticket came in: a flaky test on the retry path of a background job, failing intermittently. A developer picked it up with their local agent. The agent investigated and produced a fix. The diff removed the flaky test and changed the retry logic so the test would stop failing. From there, the change moved through three layers, and every layer failed.

Failure 1: Blind trust

The developer reviewed the diff locally, but the review was ritual. The agent sounded confident, the diff looked plausible, and the change was approved without a close reading of the retry logic. This was not a capacity problem. Developers simply relied too much on what their agents generated. They stopped critically checking the output, and they did not force the agents to create proper proof of what they did. A confident agent is not evidence; proof is. Skills and hooks do not fix that. They scaffold a process that still requires a human reading the diff and asking for proof.

Failure 2: The automated PR pipeline

The PR process was manual before. When the agents made the team faster than the manual process could keep up, the team asked its agents to design the automated replacement. The solution the agents proposed simply did not include an agentic review step. The team accepted it as-is: nobody challenged the proposal, and nobody ensured a human in the loop. Every PR was accepted automatically once static analysis succeeded.

Static analysis, style rules, and dependency checks all came back green, and that was the entire gate. Nothing in it checks whether a change means what the ticket says it means. Removing a test and swallowing an error path is formally correct. Semantically, the retry path stopped surfacing failures. The merge happened without anyone looking at the meaning.

Failure 3: The unread board

The team did something awesome with the PO process. An agentic PO looks at issues moved across the Kanban board every day, reviews changes on a technical level, demands proof where things do not look logical, and adds comments to the issues. It did exactly that here. The comment pointed out that the removed test was the one that had caught a data-loss bug, and that the retry path now swallowed timeouts. The coding agent had marked the issue done and never checked the board again. The comment was never read.

One change produced three failures at three layers. None of it was malicious; all of it was structural.

What This Means

The fixes are process fixes, not agent fixes. They did not need better agents; they needed critical distance and a view of the whole system. And this is exactly where humans become more valuable, now and in the future. Holistic oversight is what separates a proper agentic approach from agents used for the sake of speeding things up. Agents delivered the performance. Keeping the quality side of the equation is human work.

The Fix

All three failures got fixes, not just the loudest one. The PR gate comes first because it has the most impact: it is the last point before code lands, and it would have caught both earlier failures. The pipeline now ends with an automated agentic review step after the static checks, and then a human reads the result with the context the pipeline cannot hold. Static analysis is not review.

The other two fixes are equally important and easier to implement. Local review is back: developers critically check what their agents produce and force the agents to show proof of what they did. The feedback loop is closed: coding agents check the board again once they mark an issue done, so the PO agent's comments actually reach them.

If that means slowing down for a few weeks, we will. Iterations compound, and so do mistakes. A loop that closes slowly beats a loop that never closes.

Verdict

We got 7x faster. The bottleneck is no longer the agents; it is us. That is the point: holistic oversight is human work, and it is exactly what separates a proper agentic approach from agents used for speed alone.