Coding Agents in Real Codebases: What They Cost and Where They Fail

In an empty repo, every second agent writes a TODO app in five minutes. In a 200,000-line codebase with 12 years of history, things look different. The question is no longer "can the agent do this?" but "what does it cost us if we let it?".

Where Coding Agents Reliably Deliver Today

Three task types currently come out better with agents than if a human alone tackles them:

• Repetitive migrations. A loop over 70 module names renamed to the same scheme is agent work. Clear diff reviews, no hand-wringing.
• Writing tests against existing code. A well-specified skill ("write tests for the exported functions in src/lib/billing.ts") returns 20 tests in ten minutes. What stays in is decided in review.
• First-aid research. "Where does logic X live?" - agents with repo search and read access beat any IDE search for that.

Where They Still Fail

Just as honestly: three areas remain human work.

1. Architecture decisions with a long shadow. When the answer is "it depends", the agent typically invents reasons.
2. Performance tuning without telemetry. Without metrics on the table, the agent guesses. Result: ten theoretical optimizations, none measurable.
3. Code in thinly documented codebases. Without docs, tests, or conventions, the agent ships plausible-sounding solutions that violate invisible contracts.

What Tokens Actually Cost

For non-trivial tasks we see 50,000-200,000 input tokens and 5,000-30,000 output tokens on average. That works out to between 5 and 30 euros per developer per day - well below that with good setups using the Caveman pattern or similar token-saving tricks. That is not the expensive part. The expensive part is review time for output that should never have been produced.

Four Antipatterns We See in Every Other Project

• "Big-bang" prompts. "Refactor module XY" returns 800 changed lines no one can fairly review.
• Missing success criteria. "Make it better" has no stop condition. Agents hallucinate further improvements until they are halted.
• No tests in the loop. An agent without test feedback builds its own truth. With a test runner in the loop, a large share of bugs surfaces before review.
• No context budget. Every tool call pulls context. Without discipline, the window fills with irrelevant clutter and the agent loses the plot.

A Pragmatic Middle Ground

Coding agents do not replace engineering judgment, but they shift the lever. Three measures cover most teams:

1. A shared, versioned skill catalog (see our piece on skills).
2. Pull requests remain the only path into the main branch - regardless of who wrote the diff.
3. One retrospective per sprint on the question: "which task should have used agent output but did not - and which task did not need it at all?".

With that discipline the gain sits where tasks are cleanly bounded - and a noticeably crisper separation emerges between "agent work" and "human work".