Two ways to connect: the skill and the MCP

PassbackAI connects to Claude two ways — a skill and an MCP server. They're peers, not a stack: the skill sharpens how Claude writes a passback document; the MCP carries documents to you and pulls your answers back. Run either one on its own. Run both and you've got the whole loop. Not sure which? The skill makes Claude author better; the MCP removes the copy-paste — most people end up with both. And if you'd rather connect nothing, there's always the floor: paste a draft and go.

The skill — so Claude asks first

The /passback skill teaches Claude the harder half of the job: spotting the open questions buried in a request, knowing when it's worth stopping to ask, and authoring a real document — prose with embedded questions — instead of guessing. It's a plain SKILL.md, so it installs into Claude's Skills — and, now that ChatGPT has Skills of its own, into ChatGPT too. And it earns its keep with or without the MCP — it sharpens what the model writes whether you paste the result or route it.

1. Download the .zip above.
2. In Claude, open the main menu and choose Customize → Skills, then upload it.
3. Invoke it inside Claude with /passback.

Prefer to let Claude install it? If Claude can fetch a URL, paste this in and ask it to install the passback skill:

On ChatGPT? It's the same file. Open Skills, choose Create → Upload, and pick the .zip you downloaded above — ChatGPT scans it, then you invoke it by name like any other skill. (ChatGPT is rolling Skills out plan by plan, so the menu appears once your account has it.)

The MCP server — no copy, no paste

Connect PassbackAI as a connector once, and the round-trip stops being something you do by hand. Claude routes a document to you with its route_document tool — it opens at a review link, you mark it up — and reads your notes back with list_responses. The paste-back, minus the paste. And because those tool descriptions already carry the shapes of the interactive pieces, a connected Claude can build a working questionnaire with no skill at all — the MCP is a whole loop on its own.

1. In Claude, open Settings → Connectors.
2. Add a connector and paste the server URL above.
3. Authorize it. Adding the URL kicks off sign-in (OAuth); you confirm it's you, and the connection is live.

The server speaks the open Model Context Protocol, so it isn't Claude-only. Connect it from Claude or Claude Desktop, and from other MCP clients like Cursor and Cline — the server URL is the same everywhere. (The skill drops into Claude's or ChatGPT's Skills; the MCP is the half that reaches every other client too.)

One thing to be straight about: routing a document is the deliberate, opt-in exception to staying on your device. When Claude routes a doc to you, it's stored on the PassbackAI backend, encrypted with server-managed keys — not end-to-end encrypted, and not local. Nothing routes anywhere until Claude does it on your behalf. The full posture is laid out at /privacy.

Or install nothing at all

You don't have to connect a thing. Copy any draft you're not happy with, paste it into the site, and start marking it up. This path is fully local — your document never leaves your browser: no upload, no account, nothing in the loop. It's the floor, and it's always there. The skill and the MCP just save you the carrying.

The prompts — what to ask Claude for

However you connected, the last mile is knowing what to ask for. These three cover the three moments: before the work, after it, and when you just want to understand something.

With the skill installed you don't need to copy any of them — a bare /passback offers the three by name and takes a number, and /passback at the end of a working session runs the first one straight away. The text below is the same three asks, for pasting into a Claude that hasn't got the skill.

Turn this into a Passback document instead of answering in chat.

Open with a short, plain summary of what you did and what it changes for me.

Then give me the decisions that are genuinely waiting on me. For each one: the context in a sentence or two, what each option would actually mean in practice, and your own recommendation — with the reason behind it, and what would make you change your mind.

Assume I am smart but have no technical background. Simple language about a real tradeoff, never a simplified tradeoff.

Anything you already decided, or that has one obvious answer, stays as prose I can comment on — do not manufacture choices to fill the page.

If one decision would change the answers to the others, send that one first, on its own, and keep the rest for a second document.

Read what I just gave you and turn it into a Passback document of the open questions — the things that have to be decided before this can move.

Include the ones nobody wrote down: decisions someone assumed silently, places where two things I said pull against each other, and anything missing that you would otherwise have to guess at.

For each one, give me the context, the realistic options, and your recommendation. Skip style preferences and anything you can work out for yourself.

Keep whatever is already settled as prose, so I can comment on it directly.

Write this up as a Passback document: a detailed, step-by-step guide in the simplest, least technical language possible.

Each step should say what happens, who or what does it, and what I would see or do.

Do not ask me anything. Where something is unclear, make the sensible call and mark it in one line as an assumption, so I can correct it by commenting.

Upgrading the skill?

Same three steps — download, upload, invoke. One housekeeping note: if you still have the legacy question-extractor skill installed, remove it so it stops triggering. /passback replaces it.

What's new

• v4.2Fewer questions you skip anyway — when the model can confidently recommend an order, it now writes the list in order and you comment only if you disagree, instead of asking you to rank it (in our own routed documents, not one ranking came back changed). It also stops closing documents with a catch-all "anything else?" question, which mostly came back blank — you can already comment on any passage
• v4.1A one-click link no longer opens with a broken question in it — without the connector, the model packs your document into a link with a small script, and that script only checked that each question was readable. A question in the wrong shape (a single-choice with several recommendations, a version written as a number, a diagram not written as data) still went out and showed up as a block of raw code. Now the script checks every question and diagram by the same rules the server uses, names what is wrong, and gives no link until the model fixes it
• v4.0Your answers now move the work forward instead of ending in a summary — when you answer, the model continues the task it was doing with your decisions: it re-checks its reasoning where you picked against its recommendation, weighs your "Other" text as a new option, leaves anything you skipped open instead of guessing it, and writes the decisions down where the work lives. Connected, it routes the open decisions straight away instead of asking first, and you are the reviewer unless you name someone else. The skill is rewritten around five principles and is about half its former size, so it costs less every time it loads; Hebrew documents get explicit guidance for labels and diagrams
• v3.18The model hands you the right link and knows when to stop waiting — the link it gets back is your private preview (you create the reviewer's share link from it), and it now says so instead of calling it a reviewer link. The server now tells it when the roughly 15-minute wait is over, and it looks up a missing document itself (list_updates) instead of asking you for an id
• v3.17Your answers arrive without you having to say "I answered" — on the connected path the model sent the link and ended its turn, so you had to come back to the chat to wake it. Now it stays in the turn and waits (wait_for_responses) for about 15 minutes, picking your answers up the moment you submit. It also checks that the connector is really missing before falling back to a link or a code block, instead of guessing from the tool list
• v3.16The chat reply is the way in, not a second copy of the document — the connected path had no reply template, so the model reprinted the questions, options and recommendations under the link, and sometimes left the link as a bare, unclickable URL. Now every path has a fixed reply: a Markdown link, at most one or two sentences of context, the decision count, and how answers come back (connected: "tell me when you're done and I'll read them", never "paste them here").
• v3.15Answers come back as the compact bundle, not as a second copy of the whole document — in v3.14 a link reviewer answered with Share back, which packs the WHOLE document plus the answers into a new link; pasted into the chat that cost about 4x the tokens of the answers alone, and the model paid again re-copying it to decode it. The link now marks its document as captured from Claude, so the reviewer clicks Pass back, which copies only the answers and comments, and the app walks them back to the chat
• v3.14Without the connector, the document arrives as a one-click link instead of a block to copy — a PassbackAI share link already carries a whole document inside its #s= fragment, but that token is gzip + base64url, which no model can compute by hand. Now, wherever Claude can run a shell command, it runs one fixed recipe that packs the document into a link: one click instead of copy, open, paste. The code block stays as the equal fallback (no shell, a recipe error, or a document too long for a link). The recipe also parses every component before packing it, so a block that would render as raw JSON gets fixed before you ever see it. And the return trip closes the same way: a reviewer who opened a link answers with Share back, which hands back another link, and the skill now decodes that link into the reviewer name, each question with its answer, and their comments
• v3.13The three standard asks now live in the skill, so nobody has to remember a prompt — summarize-then-decide, pull-the-open-questions, and explain-step-by-step were folklore: they worked, they were re-typed from memory, and a first-time user had no way to know they existed. A bare /passback shows the three by name and takes a number, and /passback at the end of a working session runs the first one instead of stopping to ask. Each ask carries the clause that makes it work: a recommendation WITH its reason and what would change it (the half that was always missing), "simple language about a real tradeoff, never a simplified tradeoff" in place of the explain-like-I-am-15 framing that reliably produced condescension, and — on the no-questions guide — "state the assumption in one line" so an unclear point stops becoming a silent guess
• v3.12The no-MCP delivery path is specified, not improvised at the end — without the connector the skill was at its least reliable: it would sometimes WRITE THE DOCUMENT TO A FILE (on a coding surface the reflex for a long Markdown document is to write it out, and the skill had never once said not to), sometimes print the questions as loose chat prose with the component fences broken or missing. Three causes, three fixes: the paste format was a cross-reference 76 lines away from the point of delivery, so it is now stated literally and in full inline, with a skeleton of the four-backtick wrapper; nothing anywhere forbade a file, an artifact or a canvas, and now an explicit rule does (the document is text in the reply and nowhere else — a file re-introduces the find-select-copy friction the one-code-block contract exists to delete); and the delivery path was discovered AFTER authoring, with “preferred”/“fallback” framing casting paste as degradation — a new step 0 settles the path before weaving and states that paste is the full local loop, not a broken connector
• v3.11The shape check, run on BOTH delivery paths — a component whose JSON does not match its own fence tag is not a degraded widget, it is a wall of raw JSON in a grey box on a link that works, and the skill used to point at the wrong risk: it warned loudest about smart quotes (which the tolerant parser recovers) while calling a wrong recommended "graceful-ignored, a wasted nudge" — true of a wrong LABEL, fatal for a wrong TYPE (an array on a single-choice kills the block). Now one FATAL list against one COSMETIC list, applied on the MCP path too — and route_document itself rejects a block that cannot render, so a link whose widgets are raw JSON can no longer be created at all
• v3.10The proactive trigger keys on the SHAPE of the ask, not on who raised it — it used to fire only when the CONVERSATION had surfaced the open points, so 3+ decision-shaped questions the model itself authored (in a plan, a summary, an artifact, a PR comment) fell outside it and got pasted into chat; now 3+ open decisions awaiting the user fire it whichever side wrote them, guarded so a question you can answer yourself never counts. And a visual deliverable is complementary, not a substitute: the artifact is what you LOOK AT, the routed doc is how you ANSWER
• v3.9The MCP connection is OPTIONAL, and the description now says so — missing, unauthorized, erroring and never-installed are one case, and none of them block delivery: the skill falls back to the local paste document, and never hand-rolls a substitute (no invented /r/ link, no ad-hoc form, no plain-prose list of the questions), so a model that reads only the frontmatter knows both halves
• v3.8Approval dead-end: one attempt, then paste — a client-side tool-approval prompt that stalls or grants only one-shot (the mobile app) is a delivery failure, not something to retry in a loop; after one attempt the skill falls back to paste so the user always leaves with the document, and names the one-time fix (approve the tool once from a surface that shows the dialog, e.g. desktop, choosing the lasting allow)
• v3.7Long documents: communicate, don't shrink — the skill now says up front, in one line, that routing a long document takes a while (it is re-generated inside the tool call), and offers a staged split ONLY when it adds value: a dependency split where round-1 (hinge) answers, pulled via list_responses, sharpen the round-2 weave; capability is never trimmed to shorten the wait
• v3.6youtube (verb: watch) joins the palette as a DISPLAY block — embed a video the reviewer watches and reacts to (it collects no answer and sits outside the settled-vs-open law); reach for it whenever the doc references a video, passing the 11-char video id only — never a hand-written Markdown image link or an img.youtube.com URL
• v3.5allocate (verb: split) joins the palette — divide a fixed whole across categories by weight (percentages/dollars → allocate, 1st/2nd/3rd → prioritize); and the law is now two-sided: a settled decision stays prose (ceiling), an open one always becomes a component with open-question as the floor — never demoted back to prose — so a doc with real open points is never hollow
• v3.4The epistemic formula — the scan now maps the decision space (reconstruct the goal, enumerate what it requires deciding, diff against what the text settles) so silently-made decisions surface too; options must partition the plausible answers; every lead-in states the tradeoff and what would change the recommendation; components arrive in blocking order with the hinge decision named; plus a pre-delivery "read it as the reviewer" check, and weave-quality hints returned by route_document
• v3.3Proactive offer — when a conversation itself piles up 3+ unresolved open decisions, the skill offers once (non-pushy) to weave them into one PassbackAI page, instead of only firing on an explicit request; strict-spec frontmatter so it installs on third-party hosts (e.g. Dust)
• v3.2Shortened the SKILL.md description — the old one exceeded the 1024-character limit some install surfaces enforce, blocking upload; no change in behavior
• v3.1Language-agnostic triggers — the skill fires on its trigger intents in any language (Hebrew stays as an example, not the only non-English set); authorship metadata corrected
• v3.0The palette — one primitive per unclear point (single-choice, multi-choice, open-question, prioritize; questionnaire now GROUPS related questions), woven into prose; the REVIEW-vs-ASK question is gone
• v2.3One-click copy — paste output is a single code block; and it asks feedback-only vs feedback-with-clarification-questions when unspecified
• v2.2Use recommended more freely; prefer the default Other
• v2.1ASK authors a document, not a form — prose sets up each question before it, one question per embedded fence, and the "why" moves out of the per-question context field into that lead-in prose
• v2.0One skill (/passback), three jobs — review prose, ask (questionnaire + prioritize), pull answers. Replaces question-extractor; sharpened prioritize gate
• v1.6MCP delivery (route_document) — when connected, route the questionnaire as typed blocks[] (server-validated, returns a reviewer link) instead of pasting JSON; paste is the fallback
• v1.5Recommended option (recommended) — flag the suggested pick; the app shows a "Recommended" badge without pre-selecting it
• v1.4Output hardening — emit the JSON in a fenced code block with straight quotes, and self-validate the exact key names (question, not q) before sending
• v1.3Free-text questions (open_field + empty options) — ask an open question with no preset choices
• v1.2Multi-select questions (set multi: true) — checkboxes + bullet-list export
• v1.1Sections, routing, default Other field with edit-into-Other gesture