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?

Maybe one of them will, eventually. But the step where you correct a draft sits between every model and your next prompt, and you don't use only one model. A highlight tool inside one vendor's chat box wouldn't give Claude, ChatGPT, Cursor, and Gemini the same structured feedback in the same place. That cross-platform seam is the durable part: PassbackAI is the surface your AI routes into, whichever AI it happens to be.

Is this safe for confidential documents?

Yes — for the review tool, which is what this is. Your document never leaves your browser: you paste it, mark it up, and share it as a link, all locally, with nothing uploaded and no account to log into. (The site loads anonymous page-view analytics from Vercel; your document is never part of those pings.) Two paths are deliberate, opt-in exceptions, and they differ. Share by private link and your browser encrypts the document first — end-to-end encrypted, with the key kept in the link, so what we store is ciphertext. Route a document to a reviewer through your connected AI and it is stored with server-managed keys instead — not end-to-end encrypted, so we could read it. Neither happens unless you choose it.

PassbackAI is the review-and-passback loop for AI drafts — it gives a language model (Claude, ChatGPT, Cursor, Gemini) structured multi-point feedback on its last Markdown answer. You paste the answer, mark every passage that needs work, attach a note per passage, and pass the whole set back 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

Your AI Draft Is a Train Station

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. Not because it failed: because it did its job. PassbackAI is built for those four minutes. It isn't 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 those six things fixed. Precisely. Without disturbing the eighty-two percent you liked.

And the field in front of you is a single text area — the same one you used to ask for the spec. 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, drops half your instructions, or rewrites something you never mentioned. Watch yourself give up. You've 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 sits upstream: writing each correction in prose, with the original scrolled out of view, was itself hard enough 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: your draft is a 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: an AI answer 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. Not because it failed — because it's spent. Its job was never to be kept; its job was to be judged. Everything worth keeping left in your marks: what the model got wrong about what you wanted, and what it should believe instead.

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, and immediately boards the next train back to the model. The text is temporary; your workflow is constant. The texts are ephemeral; the habit is durable. And look at what actually boards that train: not the draft — your marks. The station doesn't move documents; it moves judgment. (The long version of this argument — why the marks, not the drafts, are the asset worth keeping — is The Delta Principle.)

This is also the whole reason the tool feels weightless. Because the value expires in minutes, there's nothing to file. No document to name, no folder to choose, no archive of dead versions to prune. Software that treats text as precious makes you its librarian; software that treats text as in transit asks nothing of you after the round-trip. The feedback is meant to be easy and flexible precisely because, a second later, the draft it was about is meaningless. Lightness isn't a feature we added. It's what's left once you stop saving the wrong thing.

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

The name isn't a description of software — it's the instruction. There are two ways in: you paste the model's answer into a browser tab, or your AI routes it to you directly. Then you 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). Each mark is a unit of your judgment with its anchor attached: the quote pins exactly where, the note says what you meant.

There's no blank page here, and that's on purpose. You can't write a draft from scratch — the constraint is the promise, not a limitation. It keeps you out of the exhausting trap of rewriting the model's work by hand. Your one 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. You point; the model does the lifting. You are the director, not the typist. The marker is the interface the chat box never gave you.

And there are two ways back out. Click Copy, and the whole set comes out as paired passages and notes, in document order, separated by --- — the format a language model reads without prose interpretation — and you paste it into whatever chat gave you the draft: Claude, ChatGPT, Cursor, Gemini. Or, when the draft rode in from Claude over its connected MCP link, you send your marked-up answer straight back without ever leaving the page — the deepest-wired version of the same move, not a different product. Either way, 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 station, same marks, same one-shot export. Hand someone a link and they don't land on a dead read-only view; they add their own layer of notes on top of yours and send it back. The tool does not care whether the next reader has a pulse.

4 · Local by default, routed only on purpose

If a draft becomes worthless the moment the model regenerates it, why would we file it away in a database? By default, we don't. The tool you'll use most — paste, mark up, copy — runs entirely in your browser. Nothing you paste is uploaded; the document lives in this tab, on a shelf of your twenty most recent drafts (plus anything you pin) — older ones quietly make room. Share it with a plain link and the whole document rides inside the link's own address, so there's still nothing sent to a server — add a password and that link is end-to-end encrypted. Open DevTools, watch the Network tab while you paste and mark up, and you'll see no request carrying the doc.

There are exactly two ways a document leaves your browser, both moves you make on purpose, never defaults — and they are not the same. Hand someone a private link so they can respond, and your browser encrypts the draft before it goes: it's end-to-end encrypted, the key riding in the link where our server never sees it, so the copy we hold is ciphertext we can't read. Route a draft to a reviewer through your connected AI instead, and it's stored under server-managed keys so Claude can read the responses — encrypted at rest, but not end-to-end, and I won't pretend we can't read a doc you routed. Naming that difference plainly is the whole point. Nothing leaves by default. Egress is a decision you make, not a thing that happens to you. The full posture, path by path, is at /privacy.

5 · The engine: a bench and a transit check

Two mechanisms make the station run, and both exist only because text is in motion.

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. Text moves 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 cleanest proof of the whole argument: if drafts were archives, you'd never need a diff. You need one precisely because they're in transit.

An AI draft is a train station, not a home. It's worth everything for four minutes, and then it's spent — paste it, mark the fixes, pass it back. The drafts don't survive those four minutes. What you said about them does.