Why does repeated PR rework become so expensive with coding agents?

Why repeated agentic rework compounds instead of resetting the cost

With coding agents, each failure is not just a bad attempt. It becomes new input for the next attempt, so the system has to re-read the broken output, absorb the correction, and continue from a noisier prompt. That means the cost of iteration includes both the new work and the overhead of recovering from the last miss.

Compared with a single-pass coding task, the economics change because the agent is stateful across retries. If the first pass is wrong, the next pass usually carries forward the bad artifact, the error explanation, and any partial edits, so the prompt grows while the context becomes harder to reason over. That is why rework can feel disproportionately expensive even when the fix itself looks small.

The core issue is that agentic coding does not fail in isolation. A failed attempt can leave behind rewritten files, half-correct diffs, or tool actions that the next pass must inspect and potentially unwind. The more the agent has already changed, the more expensive it becomes to determine what should be kept, what should be reverted, and what still needs to be generated.

Where the hidden cost actually comes from

The main expense driver is compounding context. Every retry typically adds failure details, revised instructions, and more source material into the working window. That increases token usage, but it also increases the chance that the next run will miss the real problem because the prompt now contains more noise, more competing instructions, and more artifacts to reconcile.

There is also a control-plane cost. In practice, coding agents often need extra review, extra validation, and extra diff inspection after a miss because the system has already demonstrated that it can produce plausible but wrong output. Once that trust drops, the workflow shifts from generation to supervision, and supervision is slower than letting the first pass stand.

For teams building with AI coding agents, this is why a small failure can have a larger effective cost than a small human coding mistake. The agent may regenerate code quickly, but it does not absorb ambiguity cheaply. It has to carry prior context forward, and that context is exactly what makes repeated work more expensive than a clean pass.

Why the problem gets worse as the task grows

Rework scales badly when the task spans multiple files, tools, or dependent changes. In those cases, one wrong edit can force a broader rollback or a second-pass reconciliation across files that were never supposed to be touched. The agent then pays again for discovery, reasoning, and regeneration, while the human reviewer pays again for verification.

This is also why vague instructions are costly. If the original prompt leaves room for interpretation, the agent may confidently choose the wrong implementation path and only discover the mismatch after producing a complete but unusable result. The retry then has to correct not just the code, but the underlying framing of the task. That is a much more expensive kind of rework than fixing a syntax error.

Repeated rework becomes especially inefficient when the agent has already modified stateful artifacts such as configuration, dependency manifests, or generated tests. At that point, the next attempt is no longer starting from a blank page. It is operating in a partially changed environment, which makes both generation and validation slower and more error-prone.

Risk and Threat Considerations

When coding agents are allowed to iterate automatically, repeated failures can turn into wasteful tool use, accidental file churn, and broader blast radius if the agent keeps acting on a bad assumption. The cost is not only compute. It can also include corrupted workspace state, misleading test results, and time lost to debugging an error trail that the agent itself created.

Failure mechanism: A wrong first pass expands the next prompt with failure context and partial edits, which increases token usage, weakens signal-to-noise, and can steer later attempts further from the real fix.

Impact: Rework costs rise nonlinearly, review burden increases, and a small initial miss can cascade into multiple regeneration cycles, broader rollback, or unsafe follow-on changes.

Practitioner Guidance

What to prioritise: Treat retry cost as a workflow design issue, not just a model-quality issue. The highest-leverage fix is usually to reduce the chance that the agent enters a long failure-retry loop in the first place.

What to verify: Before letting an agent continue after a miss, verify whether the failure was local, such as a bad line or test expectation, or structural, such as the wrong plan, wrong file, or wrong dependency assumption. Structural misses are the expensive ones because they contaminate every later pass.

What good looks like: The agent produces bounded diffs, the prompt stays small, and retries are rare enough that review effort remains lower than the work saved. If retries are growing the instruction set faster than they are improving the output, the process is already inefficient.

Practitioner takeaway: The expensive part of repeated PR rework is not the second attempt alone, it is the accumulation of bad context, extra supervision, and state cleanup across every failed pass.

Related resources from NHI Mgmt Group

• Why do AI coding agents become expensive in long-running sessions?
• When is it crucial to implement least-privilege access for AI agents?
• What is the difference between managed identities and hardcoded secrets for AI agents?
• Why do AI agents make non-human identity governance harder?