How to give Claude feedback without copy-paste — the MCP loop

By Elad Diamant·Published July 9, 2026

You and Claude are six rounds deep into the launch plan, and the loop itself has become the job: copy the draft out of the chat. Switch tabs. Paste it into the review tool. Mark up the four things that are wrong. Copy the feedback. Switch back. Paste. The feedback lands — the anchored format works — but somewhere around round four you notice your actual role in this system: you're the courier.

Connect PassbackAI to Claude over MCP, and both legs of the carrying disappear. Claude hands you the document at a link. You mark it up. Claude reads your feedback back itself — as data.

You became the courier

The manual loop is genuinely good — it's the whole case of the guide: paste the draft, anchor every comment to its exact passage, pass the batch back in one turn. What's left over is the carrying. Every round trip is four context switches and two clipboard rides, and the clipboard is a lossy courier in both directions: on the way out you're hauling a wall of Markdown; on the way back you're trusting that the paste arrived whole, in a chat box that treats your carefully anchored feedback as one more message.

And there's a subtler tax. When Claude has questions for you — which option, which tone, which of these three scope cuts — the chat makes you answer them as prose, one at a time, each reply re-describing what it refers to. The conversation becomes twenty short messages doing the work one structured document could do.

Model Context Protocol exists for exactly this shape of problem: let the model call the tool directly instead of making the human ferry data between them.

The loop, minus the clipboard

Claude routes the draft. Once connected, Claude has a route_document tool. When a draft is ready for your eyes — or when you tell it "send this to me for review" — it routes the document and gets back one review link, /r/<id>. It shows you the link; opening it is the preview: you see the document exactly as a reviewer will.

You review it as a document. The link opens the full PassbackAI app — the draft rendered with headings, tables, and structure intact, adopted onto your bench like any other doc, wearing a subtle marker that says who routed it. You select any sentence and pin a note to it, exactly like a pasted doc. If Claude named who the review is for, that name appears on the page as addressing — a document that arrives addressed to you reads differently than a paste.

You send it back — without copying anything. On a routed document, the Copy button becomes Send back: the same review — every anchored comment, every answered question — returns to the server in one click. No bundle on your clipboard, no tab switch, no paste.

Claude reads it itself. Back in the conversation, say "read my feedback" (or Claude checks on its own) and it calls list_responses: every response comes back with the leaf-anchored annotations — comment, edit, or delete, each tied to the exact passage — plus the structured answers to any embedded components, the verdict, and the reviewer's name. Nothing is re-described, nothing is guessed. The note you pinned to clause two arrives attached to clause two.

And the reviewer doesn't have to be you. The same /r/<id> link forwards to whoever should actually answer — a colleague, a client, the friend who knows — and their review comes back through the same Send back button, readable by the same list_responses. You're frequently the reviewer; you're never required to be.

The document that asks its own questions

Here's where the loop stops being a faster courier and becomes a different medium. Claude doesn't have to route plain prose. It can weave interactive components into the document — and the weave is the point: prose where its thinking is settled, and a widget at each point where it genuinely needs you.

There's a small palette, one primitive per kind of decision: single choice (pick one of a few options), multi choice (pick all that apply), open question (write a free-text answer), prioritize (drag a short list into order), and questionnaire (a batch of three or more tightly related questions as one unit). The discipline the /passback skill teaches Claude is to pick one widget per genuinely unclear point and set it up with the prose right before it — not to dump a form at the end of the document.

The result is a strange and useful hybrid: the document is simultaneously the context and the intake form for its own ambiguities. You read two paragraphs of the plan, and exactly where the plan forks, there's the fork — three options, one click. You keep reading. The paragraph about audience ends in a ranking you drag into order. Settled thinking stays prose (and prose is still a response channel — you can pin a note to any sentence of it); open questions arrive as the widget that fits them. Reading the draft and resolving its unknowns become the same ninety-second pass.

And because the answers are structured, what Claude gets back isn't your prose describing your choices — it's the choices: which option, which ranking, which typed-in answer, each tied to the question that asked it. Typed decisions, not vibes. That's the difference between "the user seemed to prefer the phased rollout" and knowing.

Set it up once

The MCP connector — the half that removes the copy-paste. In Claude: Settings → Connectors → add a connector → paste https://passbackai.com/api/mcp. Adding the URL kicks off sign-in; authorize it and the connection is live. The server speaks the open Model Context Protocol, so it isn't Claude-only — the same URL works from Cursor, Cline, and other MCP clients.

The /passback skill — the half that improves what Claude writes. Download it from the skill page and upload it under Customize → Skills (or point Claude at https://passbackai.com/skills/passback.md and ask it to install). It teaches Claude the harder half of the job: spotting the open questions buried in a request, knowing when to stop and ask, and authoring prose-with-widgets instead of guessing. It earns its keep even without the MCP — the document it authors is just as good pasted.

They're peers, not a stack: the MCP tool descriptions already carry the component shapes, so a connected Claude can build a working interactive document with no skill at all. Either one alone is useful. Both together are the whole loop. And the floor is always there: connect nothing, copy the draft, paste it, review — fully local.

The honest edge: routing is the opt-in exception

Everything else on this site keeps saying your document never leaves your browser, so this post owes you the boundary: a routed document does. It's stored on the PassbackAI backend, encrypted with server-managed keys — not end-to-end encrypted, and not local — because the entire point is that Claude can read the responses back. Framed plainly: it's stored on our server so Claude can analyze the answers.

What keeps it honest is that it's deliberate, every time. Nothing routes anywhere until Claude calls route_document on your behalf, in your conversation, on your account. The paste path stays fully local, the hash-share link still carries the doc inside itself — and when a routed document is done, revoking it kills the review link and deletes the document and all its responses from the server for good. The full posture is on the privacy page.

Six rounds into the plan, the courier retires. The draft knows the way to you, the questions arrive already attached to their paragraphs, and your answers walk themselves home.