Your agent rewrites whole files

Why it regenerates instead of editing

A precise edit requires the model to locate an exact anchor in your file and change only the span around it. Regenerating the whole file does not: it just emits the file again from scratch, which is the kind of long, self-consistent sequence models are best at. So the lazy path and the probable path are the same path, and it runs straight down it, carrying along changes to code you never mentioned.

The collateral damage is not malice, it is loss of fidelity. When the model re-emits a file it reconstructs your code from its own understanding, and anything it does not consider load-bearing, your comments, your import order, a deliberate bit of ugliness, gets smoothed away or dropped. The same instinct shows up when it recreates a deprecated version of a method instead of editing the one you have, which is documented behavior, not a rare glitch.

- // NOTE: keep padding at 12, design locked it (see #441)
- import { useLayoutEffect } from "react";  // used below
  export function Header() {
-   const pad = 12;
+   const pad = 16;
    // ...298 other lines re-emitted...
-   // TODO(sam): a11y pass before launch
  }
// your comments, import order, and TODO: gone

  export function Header() {
-   const pad = 12;
+   const pad = 16;
  }
// one line changed. everything else untouched,
// because nothing else needed touching.

The manual fix (free, and complete)

The fix is to forbid whole-file regeneration for small changes and to require a reviewable diff. Paste this into CLAUDE.md or AGENTS.md. It is the complete rule; there is no cut-down version behind a paywall.

## Edit, do not regenerate

- To change part of a file, edit that part in place. Do not rewrite the whole
  file to alter a few lines.
- Preserve comments, import order, and any code you were not asked to change. If
  you think unrelated code should change too, ask first; do not fold it in.
- Show the change as a minimal diff (only the touched lines) before or as you
  apply it, so I can review exactly what moved.
- If a real refactor genuinely needs a rewrite, say so and get my yes before
  regenerating the file.

1. Forbid regeneration for small changes. Require in-place edits and ban rewriting a whole file to change a few lines.
2. Protect the untouched code. Tell the agent to preserve comments, import order, and anything it was not asked to change.
3. Require a minimal diff. Ask for the change as a diff of only the touched lines so you can review what actually moved.
4. Gate real rewrites. If a refactor truly needs a full rewrite, require the agent to say so and get approval first.

The kit's starter AGENTS.md bundles this edit-in-place rule with the rest of the behavior set, so it lands in your file already phrased and ready.

The durable fix (the kit)

A rule against whole-file rewrites is only as good as the model's willingness to follow it mid-task, and under pressure the easy regeneration path wins again. The kit turns the rule into a guardrail: a hook watches for a write that replaces a file wholesale when the request was small, and blocks it, pushing the agent back to a targeted edit instead of trusting it to choose the harder path on its own.

As with every rule here, the edit-in-place instruction travels to Codex, Cursor, and Antigravity through AGENTS.md, so the behavior is cross-tool. The enforcing hooks, plus the navigator HUD that shows you what changed at a glance, run in Claude Code only. One command to install, one-time price.

The real numbers

Whole-file rewrites are a big part of why unconfigured agents produce so much more churn for the same result. In our first clean-room suite, five scripted tasks with the same model in both arms, the kit-configured agent produced about 40 percent less code for the same outcome, in good part because it edited surgically instead of re-emitting files and their incidental changes.

Kept honest: the guardrail is not free. The extra hook context added about a 25 percent average cost premium across the suite, and on trivial tasks that is pure overhead with nothing to protect. You are paying to keep your own code intact on the edits where that matters.

It is in Anthropic's own tracker

The clearest documented instance of this exact instinct is the most-upvoted report in the tracker.

• #2901closed2025-07-03The most-upvoted report of the pattern: Claude Code creates deprecated legacy methods instead of editing in place, over-engineers, and ignores single-source-of-truth rules that are written plainly in CLAUDE.md. Closed as not planned with 20+ thumbs-up still on it.

That report calls out the agent creating a deprecated version of a method instead of editing the one that exists. Re-emitting rather than editing in place is the same behavior at file scale.