Extract the open questions from any brief, as an interactive document

By Elad Diamant·Published May 14, 2026

Every brief contains the questions it didn't ask. Three things the PM didn't decide. A retention policy that was never finalized. A storage location someone wrote down as TBD and then forgot to revisit. You can feel the gaps before you've finished reading — but by the time you're done, you've moved on, the doc is still ambiguous, and the work that depends on it stalls in a Slack thread you'll lose track of by Thursday.

You can name those gaps with a prompt or with a skill. Either way you get back a document — prose you can read, with the open decisions woven in as questions you answer in place — not a bare wall of questions ripped out of their context.

The doc you didn't write the questions for

The scene is always the same. A teammate sends you a PRD. You read it once. By paragraph three you know there are decisions in here that nobody made — the authentication method isn't named, the retention policy says "TBD," and the storage location is hedged with "region-local or centralized" without a constraint that picks one over the other. The brief has the shape of a decision document but it's actually a list of half-decisions wearing a structural costume.

You can do what most people do: write a Slack reply with five paragraphs of "what about" and "did we also decide" and ship it. The brief author reads three of your questions and answers two. The remaining three live in your head until they bite the implementation a week later.

Or you can turn the brief into a document that asks its own questions back — and you have two ways to do it.

Two ways in: the prompt, or the skill

The prompt — no install, any chat. If the brief is already open in a ChatGPT, Claude, or Gemini window, you don't need to set anything up. Paste one instruction and the model does the extraction inline:

Before you build anything on this, ask first. Read the brief above, find the decisions it never actually made, and hand them back as a woven document for passbackai.com — the settled parts as prose, each open decision as a question with the context that makes it answerable.

That's the whole install: nothing. It works in any chat that can hold your brief in context, and it's the fastest way to make the model ask before it assumes — the same "interview me first" move, without a file to drop anywhere.

The skill — deeper, and Claude-native. Drop one SKILL.md file into your Claude project and the same behavior becomes a trigger: a handful of natural phrases (or just the word PassbackAI) fire it, the output is version-stamped so the app can flag a stale install, and the formatting is tuned harder than a one-off prompt can be. Same document out; more leverage if you run this loop every day.

The rest of this piece uses the skill's phrasing, because it's the tighter surface. Everything it produces, the prompt produces too.

What comes back, exactly

Both paths take any input and return one thing: a woven document — the settled thinking as prose, the open decisions as interactive widgets embedded in place. It has a few specific properties that turn out to matter:

• A capped list of questions. Maximum 12. When the brief has more than that, the skill picks the most blocking ones — the ones that, if unanswered, stall the implementation.
• Three to four option labels per question. Concrete, mutually distinct paths. Not synonyms.
• A context sentence on every question that names the place in the source where the open decision lives. So you know why the question is being asked.
• Optional sections (Authentication, Compliance, Rollout) when the brief has natural chapters.
• Multi-select when the answer is genuinely a set ("which fields to collect," "which integrations to ship in v1").
• Optional routing back to the sender when you're not the one answering — the skill names the sender at the top of the form so the recipient knows who's waiting for the answers.

The output is one paste. passbackai.com renders the whole document — prose and widgets together — and you answer the widgets in place: 90 seconds, no chat box, every question sitting right next to the context that explains it.

Worked example — the next PassbackAI mode

Suppose the brief is for the next thing on the PassbackAI roadmap — code-review mode for output from Cursor, Lovable, and v0 (which the Chrome-extension launch note already flagged as next). The brief is one paragraph:

PassbackAI code-review mode for Cursor / Lovable / v0 output. Open: which surfaces in v1, what unit a comment anchors to, what to echo back in the round-trip bundle, where pasted code lives during a session. Privacy posture should match Markdown mode but we haven't picked a storage tier.

You highlight it, paste it into your Claude conversation, and add:

/passback: surface the open decisions in the brief above — a woven document for passbackai.com.

Claude returns the woven document — the framing sentences as prose, four open decisions embedded as widgets, grouped into three sections: Scope, Format, Privacy. The "which surfaces in v1" question correctly comes back as a multi-select, because surfaces are a set, not an either/or. The privacy question carries an "I need to check with:" field — because the brief acknowledged the storage tier wasn't picked, it emits the escape hatch instead of forcing a guess. The anchor-unit question has four genuinely distinct options (line, quoted code span, function/class scope, whichever the user selects) — none of them synonyms for each other, none of them a placeholder TBD wearing a costume — and each sits under the sentence from the brief that raised it.

You copy it. You open passbackai.com in a tab. You paste. The site renders the document — the prose you can read, four questions on the widgets that fit them. You answer in 90 seconds — the ones you can answer; the privacy tier you mark with "I need to check with: privacy review." You hit Copy at the bottom of the screen. You paste the Markdown bundle back into the kickoff thread. The brief now has its decisions attached to it, with one item still pending on a named person.

Why a document beats a wall of questions

The thing a chat reply can't do is force concrete options. When you ask Claude "what's unclear about this brief?" it gives you back a list of paragraphs. You read three of them, you nod, and you close the tab. None of the paragraphs end with a button you have to push. The work of deciding is still on you, only now you also have homework.

A bare list of questions has the opposite failure: rip a question out of the brief and it floats free of the thing that made it a question. "Which storage tier?" with no context is just noise; "Which storage tier? — the brief says privacy should match Markdown mode but never picked a tier" is answerable. That's why the output isn't a list — it's a document. The settled thinking stays as prose, and each open decision is a widget woven in right where it belongs, carrying the sentence that raised it.

And each widget ends in a control you can't skim. You can't skim past a radio button the way you skim past a paragraph. You either pick an option, or you mark "I need to check with: legal" — both are answers. The questions you can't answer become visible as decisions someone else has to make, and you ship them to that person as one bundle instead of seven follow-up Slacks.

The cap at 12 questions matters too. Twelve questions takes you a couple of minutes. Twenty-four questions feels like an interview, and people don't finish those. The skill is tuned for the shortest path to "all the open decisions, on one screen, answered."

How you actually invoke it mid-chat

Three lines you can paste into a chat right now. With the skill installed they fire it by trigger; without it, they work as plain prompts in ChatGPT, Claude, or Gemini just the same. Each one is a different posture.

The brief just landed. A PRD, a retro, an email — Claude has it in context, you want the open decisions before you respond.

Turn the brief above into a questionnaire — JSON for passbackai.com.

The "interview me" posture. You're describing a problem to Claude, you don't trust your own framing, and you want sharper questions back before you keep talking.

Before you answer, run /passback on what I just told you — interview me until you have what you need.

The mid-conversation self-interrupt. You've been rambling for ten exchanges. You can feel that you don't know what you're optimizing for. Stop and let the skill name the unknowns.

Stop. I'm rambling. /passback — figure out what's still undecided and hand me the decisions.

The skill triggers on a handful of natural phrases too — "extract the open questions," "what's still unclear," "turn this into a questionnaire," or just the word PassbackAI. The lines above are the ones worth memorizing because they map to the three moments you'll actually want them.

Answer it yourself, or send it to someone else

The same JSON works two ways. Default: the skill emits a form for you — no routing block, you open PassbackAI, you answer, you copy the bundle. The other mode: the skill includes a routing.from field naming whoever's waiting on the answers ("Alex sent this"), and a return_prompt that tells the answerer how to send it back. The renderer renders the sender's name at the top of the form so the recipient never wonders who's chasing them.

This matters in practice. The PM with the half-baked brief usually isn't you. You forward them the JSON, they fill in the form on PassbackAI in 90 seconds, they copy the bundle and DM it back to you. The questions that started in your head are now answered in their handwriting.

Install the skill (optional)

To be clear: you don't have to install anything to use the prompt above — it works in any chat today. This is only if you want the skill. One file. Drop it into your Claude project's skills directory (or wherever your Claude setup loads SKILL files from). Nothing else to configure — no API key, no auth, no install script.

The chat box can't anchor your corrections to the exact passages they apply to — that's why PassbackAI exists. The chat box also can't force the unanswered questions in a brief to surface as a document you can actually finish — which is why the prompt and the skill exist. Same diagnosis, opposite direction. The arrow that points at the answer is the PassbackAI product; the arrow that points back through the question is this prompt-and-skill pair. Both end on the same document.