AI Coding Cost per Refactor: Targeted Edits vs Full-File Rewrites

When an AI agent refactors a file, it can do it two ways. It can emit a targeted edit, a diff or patch that changes only the lines that need changing, or it can regenerate the entire file from scratch. Both produce the same end result, but they cost wildly different amounts, because the difference lands almost entirely in output tokens, and output tokens are the expensive ones. Understanding this gap is one of the highest-leverage things you can know about your AI coding bill.

Why Output Tokens Are the Expensive Ones

On almost every frontier model, output is priced several times higher than input. Claude Sonnet 5 costs $2 per million tokens in but $10 per million out, a 5x ratio. That ratio is the whole story of refactoring cost. Reading a file into context is cheap. Writing a file back out is what you pay for. Any refactoring style that re-emits code you did not need to change is quietly overpaying on the most expensive side of the meter.

Why Full-File Rewrites Are Expensive

A full-file rewrite regenerates the whole file even when you are changing a single function. Take a 400-line module. At roughly 12 to 13 tokens per line of code, that is about 5,000 output tokens every time the model rewrites it. Change one variable name, get 5,000 output tokens. Adjust an import, get another 5,000. Do this across a realistic refactoring session, say 8 iterations, and you have emitted 40,000 output tokens to make changes that touched maybe a few hundred.

The waste scales with file size. The bigger the file, the more untouched code the model re-emits on every pass, and the more you pay for text that did not change.

Why Targeted Edits Are Cheaper

A targeted edit emits only the changed lines plus a little surrounding context to anchor the patch. For a small change in a 400-line file, that might be 250 to 500 output tokens instead of 5,000, commonly 10x to 20x fewer output tokens. The model still reads the file as input, which is cheap, but it writes back only the delta.

The catch is reliability. A patch has to apply cleanly against the real file. If the model miscounts lines or the surrounding context has drifted, the edit fails to apply, and the agent retries, sometimes falling back to a full rewrite anyway. A failed patch that triggers a retry can erase the savings for that step, which is why edit-application quality matters as much as the token math.

Worked Example: 400-Line Module, 6 Iterations

Refactor a 400-line module across 6 iterations. In both paths the model reads the file each time (about 5,000 input tokens per iteration, 30,000 total). The paths diverge on output. The full-rewrite path emits about 5,000 output tokens per iteration, 30,000 total. The diff-edit path emits about 400 output tokens per iteration, 2,400 total. Here is the bill on Claude Sonnet 5 (in $2/M, out $10/M):

The diff-edit path costs about $0.084 versus $0.360 for full rewrites, roughly a 4x reduction, and the entire gap comes from output tokens. Run the same session on Haiku 4.5 (in $1/M, out $5/M) and the shape holds: full rewrite lands near $0.18, diff edits near $0.042, again driven almost entirely by the output side.

Now scale it. One module across one session is pocket change, but a team refactoring dozens of files a day, many of them larger than 400 lines, multiplies that per-file gap into a serious monthly difference. The rewrite tax is small per action and large in aggregate.

Practical Guidance

• Prefer tools that patch, not rewrite. Modern coding agents default to diff-style edits for exactly this reason. If your tool regenerates whole files by default, look for a patch or apply-edit mode.
• Keep files small. If files stay under a few hundred lines, even a full rewrite is cheap, and the rewrite-versus-edit gap shrinks. Large monolithic files make every rewrite maximally expensive.
• Watch for silent edit failures. A patch that fails to apply and triggers a retry, or a fallback to full rewrite, quietly erases your savings. Malformed diffs are a real cost, not just an annoyance.
• Match the model to the task. For mechanical edits, a cheaper model applying clean diffs beats a premium model rewriting whole files on both cost and speed.

The Takeaway

Refactoring cost is an output-token problem. Full-file rewrites re-emit code you never touched, and you pay the premium output rate for every line. Targeted edits emit only the delta, typically 10x to 20x fewer output tokens, as long as the patches apply cleanly. Before you standardize on a tool or a model for refactor-heavy work, price your own file sizes and iteration counts in the AI cost calculator to see the gap in dollars.