You wrote a 200-word email, you liked 90% of it, and you asked the model to “tighten paragraph 2 and fix any awkward phrasing.” Back came a 230-word email that is undeniably smoother and unmistakably not yours. Sentence one was rewritten. Sentence four lost the joke. Paragraph 2 is now three sentences instead of four, and the word you specifically chose (buggy) has been replaced with “intermittent”. You did not ask for any of this.
Fastest fix: stop asking for the full text back. Bracket the one part you want touched, add a one-line preservation rule, and demand track-changes output instead of a rewrite. A single line does most of the work:
Edit ONLY the text inside [[ ]]. Return everything else byte-identical.
Show changes as CriticMarkup: {--deleted--}{++added++}. Do not rewrite anything I did not flag.The model over-edits because “fix any awkward phrasing” reads as a license to rewrite anything it judges suboptimal, which is most things. RLHF-tuned chat models are rewarded for producing a polished, complete answer, so when you hand them a whole document they regenerate the whole document, and regeneration always drifts. The rest of this page shows why this happens and the exact prompts and tools (ChatGPT Canvas, Claude, Gemini) that pin the model to a true diff.
Which bucket are you in
Match what you see to the most likely cause and jump to the fix.
| What you observed | Most likely cause | Go to |
|---|---|---|
| Whole document came back, including untouched paragraphs | You asked for the full text, not a diff | Step 3 |
| Specific words you chose got swapped for synonyms | No “do not touch” set declared | Step 2 |
| Sentence/paragraph count changed | No structure lock or edit budget | Steps 5-6 |
| Output sounds like a different (more “corporate”) writer | A system prompt or custom instruction is normalizing voice | Step 7 |
| It edits fine in chat but ignores you in the app’s doc view | You are not using selection-scoped editing | Step 4 |
| Even with constraints it keeps rewriting everything | Verb is still open-ended; switch tools | Step 1, “If it still fails” |
Common causes
1. Verb scope is open-ended
“Polish”, “improve”, “tighten”, “edit” — all of these are unbounded. They imply “make better wherever you can” and the model obeys.
How to spot it: your prompt verb has no object that bounds it. “Polish” vs “polish only sentences flagged in brackets” — the first is open, the second is constrained.
2. No “do not touch” set declared
If you only say what to fix, you have not said what to preserve. RLHF models prefer to produce a “complete” output, so they touch everything.
How to spot it: your prompt names what to change but does not list what must stay byte-identical.
3. Output format is “the full text”, not a diff
When you ask for the whole text back, the model has to generate every sentence — including the ones that did not need changing — and regeneration introduces drift. A diff format would force minimal change.
How to spot it: you asked for the full new version, not a list of changes or a unified diff.
4. The model thinks it is collaborating, not constrained
Default chat persona is helpful assistant. Helpful assistants improve things. If you do not explicitly say “leave alone”, helpfulness over-fires.
How to spot it: the rewrite is genuinely better in places, but you did not ask for those changes.
5. Style template loaded from system prompt
If you have a “professional writing” system prompt, it interprets the edit task in that frame: it will normalize voice toward the template, not toward your voice.
How to spot it: the rewrite sounds like your system prompt’s style, not like your draft.
Before you change anything
- Save the original text and the over-edited output for diffing.
- Note exactly which words/sentences you wanted preserved.
- Try the same prompt with a different model — confirm it is not model-specific behavior.
- Check whether a system prompt or project instruction is biasing toward maximal rewrite.
- Decide before re-prompting: do you want a diff, a tracked-changes list, or a constrained full text?
Information to collect
- Original text, byte-exact.
- The prompt you used.
- The output you got.
- A list of sentences/words you wanted untouched.
- Model, temperature, system prompt or project context.
Shortest path to fix
Step 1: Replace open verbs with bounded operations
Instead of “polish”, give a surgical instruction:
Bad: "Polish this email."
Good: "Edit only sentence 3 of paragraph 2. Keep all other sentences
byte-identical. Return the full email with that one sentence
changed and a separate line: 'Changed: <old> -> <new>'."Step 2: Declare the “do not touch” set
Add an explicit preservation clause:
Preservation rules:
- Do not rewrite any sentence that I have not explicitly flagged.
- Keep all of these words unchanged: "buggy", "honestly", "shipped".
- Keep paragraph breaks at their current positions.
- Keep my contractions ("don't", "we're") as-is.
- If a sentence is acceptable as-is, return it byte-identical.Step 3: Switch output to track-changes (CriticMarkup), not a rewrite
Asking for a Git-style unified diff works for code but is unreliable for prose: models botch the @@ hunk headers and line numbers. For text, use CriticMarkup, a plain-text track-changes syntax that current models follow well and that you can review change-by-change. The four operators you need:
{++ inserted text ++}
{-- deleted text --}
{~~ old text ~> new text ~~} (a substitution)
{>> editor comment <<} (a note, not a change)So the prompt becomes:
Return my text unchanged except for your edits, marked with CriticMarkup:
- additions as {++ ... ++}
- deletions as {-- ... --}
- replacements as {~~ old ~> new ~~}
Do not output a clean rewrite. Do not touch any sentence you are not
marking. If a sentence is fine, leave it with no markup.This makes minimum-change the default, because every edit now costs visible markup, and you can accept or reject each one. Tools like Obsidian, VS Code, and MultiMarkdown render CriticMarkup natively if you want to review it in an editor; otherwise it reads fine as raw text.
Step 4: Use the app’s selection-scoped editor (most robust)
The single most reliable fix is to never paste a whole document into chat. Use a document surface that scopes the edit to a selection:
- ChatGPT Canvas (on the paid tiers, including Plus and Pro, as of June 2026; check your plan for current availability): type “open in canvas” or pick Canvas from the tools menu, then highlight only the passage you want changed. The inline edit popover rewrites just the highlighted text and replaces it in place; the rest of the document is never regenerated, so it cannot drift. This avoids the “regeneration hallucination” entirely.
- Claude: Artifacts regenerate the surrounding block, so for byte-minimal prose edits prefer the paste-and-constrain prompt below (bracketed zone + CriticMarkup). For code, Claude’s editor tool does apply targeted replacements rather than full rewrites.
- Gemini (Canvas): supports highlight-to-edit on a selection similar to ChatGPT.
If you must stay in plain chat, bracket the only part you want touched:
Email below. Edit ONLY the text inside [[ ]]. Leave everything else
exactly as written, including punctuation, line breaks, and casing.
Hey team,
Quick update on the launch. [[Paragraph 2 about timeline, currently
awkward, please tighten.]] We can sync tomorrow if you have questions.Bracketing plus CriticMarkup output is the most robust plain-chat pattern.
Step 5: Constrain edit budget
Cap the total change:
Constraints:
- Change at most 1 sentence per paragraph.
- Net word count change must be within +/- 10 words.
- Do not delete any concrete noun present in the original.Budgets force the model to prioritize.
Step 6: For tone-only edits, lock the structure
If you want a tone shift but not a content rewrite:
Rewrite for tone only. Preserve sentence count, paragraph count, and
all factual claims. Replace at most 1 word per sentence. If a sentence
does not need tone adjustment, return it byte-identical.Step 7: Neutralize a voice-normalizing system prompt
If the output reliably sounds like a different, more “corporate” writer, the cause is usually a saved style instruction, not your edit prompt. Check:
- ChatGPT: Settings -> Personalization -> Custom instructions, and any project-level instructions if you are inside a Project.
- Claude: your account “personal preferences” / styles, and any Project custom instructions.
- API / your own app: the
systemprompt your code sends.
Either clear the style for editing tasks, or override it inline for the turn:
For this turn, ignore any saved style or tone instructions. Match the
voice of the text I pasted, not any default writing style. Preserve my
word choices and contractions exactly.How to confirm the fix
- If you used CriticMarkup, every change is visible as
{++...++}/{--...--}; scan the markup and accept or reject each one. No markup outside your edit zone means nothing else moved. - Run a diff (your editor, or
diff -u original.txt revised.txt) between original and new output; changes should be limited to your declared edit zone. - Sentences outside the edit zone are byte-identical.
- Word count change is within your declared budget.
- The voice still sounds like yours: read the new version aloud and check the specific words you wanted kept are still there.
If it still fails
- The model may be over-eager regardless of constraints. A Thinking/reasoning model often follows edit constraints more literally than a fast model, but it can also “improve” more; if yours keeps rewriting, try the opposite mode.
- Switch to selection-scoped editing (ChatGPT Canvas / Gemini Canvas) so the model literally cannot see or regenerate the rest of the document.
- For long documents, edit one paragraph at a time in isolation and combine the results yourself.
- If a system prompt or custom instruction is biasing the voice, clear it for the session (Step 7) rather than fighting it every turn.
- Drop the temperature. If you control it (API or playground),
temperature: 0reduces gratuitous rewording on edit tasks.
Prevention
- Save a personal “minimal-edit prompt template” with preservation rules and diff output baked in.
- Never use “polish” or “improve” as your edit verb. Always name the surgical operation.
- For collaborative editing, always require diff output. Convert to full text yourself only after review.
- For high-stakes edits (legal, code, brand copy), bracket the edit zone explicitly.
- Build the habit of declaring a “do not touch” list before every edit prompt.
- When voice matters, paste 2-3 sentences of your own writing as a voice anchor inside the prompt.
FAQ
Why does the model rewrite sentences I never asked it to touch? Chat models are tuned to return a complete, polished answer. When you paste a whole document, “complete” means regenerating every sentence, and regeneration drifts. The cure is to remove the regeneration step: ask for CriticMarkup track-changes (Step 3) or use a selection-scoped editor (Step 4) so unchanged text is never generated again.
What is the single best prompt to stop over-editing?
“Edit ONLY the text inside [[ ]]. Return everything else byte-identical. Show changes as CriticMarkup {--deleted--}{++added++}. Do not rewrite anything I did not flag.” Bracketing scopes the edit; CriticMarkup makes every change visible and rejectable.
Does ChatGPT Canvas really edit only the highlighted part? Yes. Highlight a passage in Canvas and the inline edit applies to that selection only; the rest of the document is left in place rather than regenerated, which is why it does not drift. Canvas is available on the paid tiers (including Plus and Pro) as of June 2026; check your account for current plan coverage.
Why does Claude keep regenerating my whole document? Claude’s Artifacts regenerate the surrounding block by design, so for byte-minimal prose edits you get better results pasting the text into normal chat with a bracketed edit zone and CriticMarkup output. For code, Claude’s editor tool does make targeted replacements.
The model swapped my exact words for synonyms. How do I stop that?
List the words to freeze and require byte-identical return: Keep these words unchanged: "buggy", "shipped", "honestly". If a sentence does not need a flagged change, return it byte-identical. Pair it with CriticMarkup so any synonym swap shows up as visible markup you can reject.
It edits cleanly in the API but over-edits in the app, or vice versa. Why? The app may carry a saved custom instruction or style that the API call does not, or the app may default to a different model/mode. Check custom instructions (Step 7) and confirm you are on the same model and temperature in both places.
Related reading
- AI rewrote key logic
- Unclear task boundary
- Model fills missing details
- Too many tasks one prompt
- No output format specified
Tags: #Troubleshooting #Prompt #Prompt quality #Unwanted rewrite