Why does Claude keep rewriting the wrong paragraph when I ask it to fix something?

Because prose descriptions force the model to infer which passage you mean, and on a long answer it usually infers wrong. The fix is to quote the exact passage alongside your note, so the mapping is unambiguous. This turns feedback from prose-the-model-interprets into paired-data-the-model-applies.

What is the best way to give an LLM feedback on multiple parts of its answer?

Quote each passage verbatim, write your note directly beneath the quote, separate each block with three dashes, and send the whole set in one message prefixed with 'apply these edits; leave everything else unchanged.' Prose descriptions, numbered lists, and multiple back-and-forth turns all fail at five or more comments. Paired passages with notes do not.

Why doesn't the chat box just have a highlight tool?

It probably will, eventually — every frontier chat interface will ship some version of multi-edit selection within the next year or two. Until then, the workaround is a separate browser-only tool that emits feedback in the format the model can parse. The primitive is missing from the chat; the primitive is not hard to provide elsewhere.

Is this safe for confidential documents?

Yes. There is no backend. Your document never leaves your browser. There is no database to store it in, no account to log into. (The site itself loads anonymous page-view analytics from Vercel; your document is never part of those pings.)

PassbackAI is a browser tool for giving a language model — Claude, ChatGPT, Cursor, Gemini — structured multi-point feedback on its last Markdown answer. You paste the answer, highlight every passage that needs work, attach a note per passage, and copy the whole set back out as one clean Markdown block. The model maps each comment to its exact passage and applies all the edits in one round-trip.

The PassbackAI Manifesto · 2026

The Smart Clipboard for the AI Era

By Elad Diamant, who got tired of typing "not that one, the other one" into Claude.

An AI draft is the most important thing in the world for about four minutes — and then it's worthless. PassbackAI is built for those four minutes. It's not a place your drafts live. It's a station they pass through: paste it, mark the fixes, pass it back.

1 · The problem: Prompt Amnesia

You asked Claude for a spec. It returned 1,800 words. It's 82% fine. The 18% that isn't is spread across six specific passages — the tone in the FAQ, a bullet under Architecture, a 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 yet. The field in front of you is a single text area — the same one you used to ask for the spec. It has no highlight tool, no per-passage note, no notion that you're holding a list of edits, each anchored to a span the model produced ninety seconds ago. So you try to describe all six in prose, in one message, and you hit the wall every LLM user knows: Prompt Amnesia. The model loses the thread, forgets half your instructions, or rewrites something you never mentioned.

Watch yourself give up. You have done all four:

Point 1, in prose

You type the first one carefully. "In the bullet under Architecture — not the second one, the third — change 'users' to 'guests.'" Forty-five seconds. You re-read it. You're proud. You have four more to go.

Point 2, with the original 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 five.

Point 3, hedged

By the third one you stop describing the location and just paraphrase the fix — "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. You send it anyway. Some shipped feedback beats none.

Points 4 and 5, abandoned

There were two more. A tone problem in the third bullet. A step that's out of order. You think, in the voice of a person who has given up: the model will probably catch those on its own. It will not. You hit send, and start another round.

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 it: the act of writing each correction, in prose, with the original scrolled out of view, was itself hard enough work that two of the five never got written. The gap isn't in the chat box. It's in you, by the fourth correction, deciding that points four and five aren't worth the writing. That moment of capitulation is the moment this whole product exists for.

2 · The paradigm shift: the train station

The biggest mistake modern editing tools make is assuming text is an asset that belongs in an archive. PassbackAI is built on the opposite premise: AI text is genuinely valuable, but ephemeral — a stepping stone, not a deliverable. The moment the model returns the corrected version, the draft you marked up is worthless.

So we didn't build a workspace in the Google Docs sense. We built a train station. A station is bustling — full of infrastructure and tools — but nobody lives there. An AI output pulls in, gets its surgical direction (your marks), and immediately boards the next train back to the model. Your workflow is constant; the text is temporary. The texts are ephemeral; the habit is durable. That's also why you never have to name a file, choose a folder, or prune an archive of dead versions — there is no archive to tend.

3 · The director's promise

There is, on purpose, no blank-canvas text editor here. You can't write a draft from scratch — and that constraint is the promise, not a limitation. It keeps you out of the exhausting trap of rewriting the model's draft by hand. You point, you mark, you guide with precision; the model does the heavy lifting of rewriting. You are the director, not the typist.

4 · The loop: paste, mark, pass it back

The name isn't a description of software — it's the action. Paste the model's answer into a browser tab. Mark every passage that needs work — five, eight, fifteen — and leave a note on each (free text, or a canned label like Delete, Too long, Off tone). Click Copy, and the whole set comes out as paired passages and notes, in document order, separated by --- — the format a language model parses without prose interpretation. Paste it back into the chat. Every fix lands in a single round-trip. No more "not that one, the other one."

Paste the draft. Mark the fixes. Pass it back.

Humans are the strong second case. Your PM, your editor, your marketing lead, your legal reviewer — same workflow, same export. The tool does not care whether the next reader has a pulse.

5 · The visual signature: the surgical marker

Because you're directing rather than typing, the core tool is a "wet" yellow highlighter. You drag it across the exact sentence that's wrong, attach a focused note, and the app turns your marks into a precise, copy-pasteable roadmap for the model to execute. The marker is the interface — the one gesture the chat box never gave you.

6 · No servers for disposable text

If a draft becomes worthless the moment the model regenerates it, why would we save it to a database? We don't. Storing ephemeral text doesn't just waste cloud storage — it wastes human focus. PassbackAI runs 100% locally in your browser: no backend, no database, no account, nothing uploaded. We removed the part a security review would object to by removing the server entirely.

And when you do need another human, the whole document — text and your marks — is encoded directly into the link. Drop it in Slack; the recipient opens a fully rendered document with no login, and — far from a dead-end read-only view — can immediately add their own layer of notes on top of yours. Every shared link is a live, Receiver-to-Creator loop.

7 · The engine and the moats

The Rolling 20 — the bench. The last twenty things you pasted wait locally on the bench. Paste a twenty-first and the oldest rolls off — never the one you're working on. Need one to stay while you work? Pin it; it stays until you unpin. A waiting bench, not a vault.
The Auto-Diff — the transit check. Texts move fast, so you go text-blind. The instant you paste a new version, PassbackAI finds the previous one on the bench and lights up exactly what the model changed — no re-reading the whole thing. It's the clearest proof of the model: if drafts were archives, you'd never need a diff. You need one precisely because they're in transit.

AI text is ephemeral; the habit is durable. PassbackAI is the four minutes between a draft and its next version — paste it, mark the fixes, pass it back.