How to give Claude or ChatGPT feedback on 5 things at once (without it rewriting everything)
You asked Claude for a 1,800-word spec. It gave you one. It's 82% fine. The 18% that isn't is spread across six specific passages — the tone in the FAQ, the third bullet under Architecture, the paragraph on retention, and three other small crimes. You want the model to fix those six things. Precisely. Without rewriting the eighty-two other percent you liked.
And this, reader, is where the chat box quietly gives up.
For one correction, you can type it into the chat. For five, you can't — by the fourth, the original answer has scrolled away and points four and five quietly become "the model will probably catch those." It will not. The format that lets you raise all five comfortably is paired passages: quote the exact passage, write your note beneath it, separate each block with ---, repeat. Prefix with "apply these edits; leave everything else unchanged." Five corrections land on five anchored targets in one paste. Do it by hand in a scratch buffer, or use PassbackAI to highlight passages in a browser tab and emit the block in one click.
What giving up on point four looks like, in real time
Watch yourself do it. The model returned 1,800 words. Six things need work. The chat box sits at the bottom of the page, one text area, the same field you use for everything. So you start typing.
You type it carefully, you re-read it, you're proud
Forty-five seconds. "In the third bullet under Architecture — not the second, the third — change 'users' to 'guests.'" Five to go. You feel like you've got a system.
The original has scrolled away
You scroll up to re-find the FAQ paragraph because you can't remember the exact phrasing. The chat box loses focus. You scroll back down. The thing you were going to say is gone. You write a worse version of it. Two minutes in, two of six.
You stop describing the location and just paraphrase the fix
By the third correction you're tired of typing directions. You write: "and somewhere there's a paragraph on retention that needs to say it more directly." You know, as you type it, that the model is going to pick the wrong paragraph on the next turn. You send it anyway. Some shipped feedback beats none. Three of six, and the next turn already has a known mis-target baked in.
The model will probably catch those on its own
There were three more. A tone problem in the third bullet. A hallucinated dependency. A step that's out of order. You think, audibly, in the voice of a person who has given up: the model will probably catch those. It will not. You hit send with three of six. The next answer comes back wrong on the other three. Round two begins. OMG.
Notice what happened. Nothing was wrong with the chat box's plumbing — your message went through, the model read it, the model replied. What was wrong was upstream of the chat box: the act of writing each correction in prose, with the original answer scrolled out of view, was itself hard enough work that three of the six never got written. You weren't lazy. You weren't impatient. You were a person sitting in front of the only input field on the page, doing the math on whether typing forty-five more seconds of directions to point four was worth it, deciding that no, it wasn't, and downgrading point four to the model will probably catch that.
That is the real failure mode. It isn't four failure modes — typing prose, the numbered list, the back-and-forth turns, the manual quoting. Those are all the same failure mode wearing different hats. They all fail in the same place: you, around the fourth correction, deciding the writing tax is more than the correction is worth. The numbered list doesn't reduce the tax — you still have to type each item. Multiple turns multiply it. Manual quoting sounds like it should help and then collapses around comment four because you're tab-juggling between the model's answer and the chat box, scrolling through a long document to find each passage, losing your place between every quote. The variations don't matter. The give-up moment is the same.
For one correction, the chat box is fine — you type it, you send it, you move on. For five, it can't carry the load. Not because it's broken. Because writing five corrections in prose, in a small text area, with the original answer scrolling out of frame as you type, is enough work that the last two don't make it into the message.
The fix is not a better chat box. It's making the writing stop being the work.
If the gap is the writing tax around point four — the moment you decide forty-five more seconds of typing isn't worth it — then the fix has to be the thing that drops the cost of raising point four to nearly nothing. Not a smarter model. Not a better prompt. A format you can fill out as comfortably for the fifth correction as you did for the first, that arrives at the model anchored to the exact passage each note belongs to, so the next turn doesn't come back wrong on point four either.
That's the only thing that has to change. Comfort while writing, on all five points. Anchoring on the way out, so five corrections land on five targets without a "not that one, the other one" round.
The format is paired passages: quote the exact passage, write the note beside it, use a separator the model can parse, send the whole set in one message. Each pair self-contained. Each annotation anchored to its passage. The cost of raising the fifth point is the cost of one highlight and one note — same as the first point, not progressively worse. The cost of the model targeting the wrong paragraph on the next turn is zero, because the verbatim quote is sitting right there.
The paired-passage-with-note format
Here's what it looks like. This is what the model actually sees:
# Apply these edits to your last answer. Leave everything else unchanged.
---
"the system can leverage a cross-functional synergy touchpoint"
[Off tone] Too corporate. "this connects to X" is plenty.
---
"delight velocity"
[Delete] We do not measure this.
---
"The FAQ currently opens with three questions about pricing."
Move this paragraph below the product-overview section — it fits better there.
---
"moreover,"
[Delete] One use of "moreover" per page, maximum. This is the third.
---
Four comments, one message, paired data. Each block is a quoted passage followed by a note. Optional label in brackets (like [Off tone] or [Delete]) signals intent without prose. Three dashes separate each block so the model can't bleed context between them.
When a frontier model receives this, it does not have to infer anything. It sees an instruction ("apply these edits"), four pairs, and the boundaries between them. It finds each quoted passage in its last answer via exact-text matching — which is a thing language models are excellent at — and applies the note to that specific region. It does not rewrite the paragraphs around your quoted passages, because you didn't quote them.
On the next turn, you can diff the model's reply against your list. The edits it applied will be visible at the exact quoted regions. The ones it skipped are almost always the ones where your quote had a typo or a whitespace discrepancy that prevented exact matching. Fix the quote, resend the missing block, done.
The manual recipe (works without any tool)
You do not need PassbackAI to do this. You need ten minutes and a plain-text scratch buffer.
- Copy the model's full answer into a second browser tab or a plain-text editor where you can scroll and select cleanly.
- For each passage that needs work, copy the exact text — punctuation and line breaks included — and paste it into a scratch block in quotation marks. Write your note directly beneath the quote. Add
---to separate it from the next block. - Order the blocks by document position. If your first comment is about the opening paragraph and your last is about the conclusion, the blocks should appear in that same order. This matters more than it looks — the model applies edits in a single pass, and out-of-order edits make it work harder.
- Prefix the whole thing with a single clear instruction: "Apply the following edits to your last answer. Leave everything else unchanged." Without this prefix, the model will sometimes rewrite surrounding passages "for consistency." With it, it almost never will.
- Paste the block into the chat as one message. Send.
- Diff the reply. The model should have applied every edit in one turn. The ones it skipped are quote mismatches; fix and resend those specifically.
This works on Claude, ChatGPT, Cursor, Gemini, and any local model large enough to hold the original answer in its context window. It's not a prompt-engineering trick — it's a format you can fill out for the fifth correction as comfortably as the first, which is the only thing that has to be true for all five to make it into the message.
Or: use a tool that does the quoting and separators for you
We built PassbackAI because the manual recipe, while it works, takes ten minutes and some amount of tab-juggling. The tool replaces step 2 entirely: paste the model's answer, highlight every passage that needs work, attach a note per highlight, click Copy. The tool emits the paired-passage block in the format above, pre-ordered, with separators and labels. You paste it back into the chat.
Full disclosure: we built it in an understandable fit of frustration. It's browser-only; your document never leaves your browser. Use it or don't — the recipe above works either way. But if you are reading this piece because you have spent forty-seven minutes this week typing "not that one, the other one" into a chat window, the tool is what we built for the version of you who is having that week.
Why this is what works, in one paragraph
None of this requires a smarter model. The model that wrote your 1,800-word answer already applies five clearly-anchored corrections in one paste when it gets them — that part has worked since early 2024 and will keep working until a frontier chat app ships native multi-edit selection (which is coming, probably inside of a year). The bottleneck was never the model. It was the four minutes between you reading the answer and you giving up on points four, five, and six. The paired-passage block is the format that takes those four minutes and makes them feel like one — so the corrections you used to abandon now ride along in the same paste as the rest, anchored to the exact passages they belong to. The model's job stays easy. Yours stops being hard. That's the whole trick.
If you want the argument for why this should exist as a primitive in every LLM chat interface, read the manifesto. If you want to try it, the tool is right there.