When AI Code Is Fast but Shipping Is Slow

A coding agent opens a huge pull request. The diff looks impressive. The velocity chart looks healthy. And still, no one wants to merge it.

This is the hidden tax in AI coding. We keep measuring how fast code is produced, while the real bottleneck is how fast humans can understand what was produced.

I think most teams are now choosing between two execution modes. Additive work: build incrementally with the agent and verify each step as you go. Subtractive work: let the agent produce a large draft, then trim and fix it at the end.

Claude-style workflows often fit additive work. You can review one change at a time, prove each decision, and build a mental model in parallel with implementation. You are not just checking output. You are building authorship.

The tradeoff is obvious. Additive work demands many microscopic decisions: naming, boundaries, tests, edge cases, and refactors. It protects understanding, but it can burn attention.

Early Codex-style workflows often fit subtractive work. Ask for a larger outcome, get a larger patch, then shape it. When the first pass lands at 95 percent or 99 percent, this is a fantastic trade. You keep speed and still preserve quality.

The failure case is what I call the 80 percent trap. At 80 percent quality, subtractive work stops feeling like editing and starts feeling like archaeology. To fix the last 20 percent, you must first decode the earlier 80 percent. Context switching rises, confidence drops, and cycle time quietly expands.

So the decision is not additive versus subtractive in the abstract. The decision is conditional: at this expected quality level, for this task, which burden do we want to pay now? Many small decisions during the build, or heavy reconstruction after the build.

Neither mode is the winner. The winner is a team that switches modes intentionally. Subtractive when quality is predictably high and scope is tight. Additive when requirements are moving, risk is high, or the code path is strategically important.

AI code generation will keep getting faster. The teams that outperform will be the ones that manage comprehension as a first-class resource, not a cleanup step.