Extract the open questions from any brief, with one Claude skill

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.

This skill names the gaps. Then it makes you answer them.

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 run the skill.

What this skill does, exactly

The skill takes any input and returns one JSON object. That's it. The output 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. The renderer at omgfixmd.com reads it, builds the form, and lets you answer with radio buttons and checkboxes — 90 seconds, no chat box.

Worked example — the next OMGfixMD mode

Suppose the brief is for the next thing on the OMGfixMD 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:

OMGfixMD 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:

question-extractor: turn the brief above into a questionnaire — JSON for omgfixmd.com.

Claude returns a JSON object with four questions, grouped into three sections — Scope, Format, Privacy. The "which surfaces in v1" question correctly comes back as multi: true, because surfaces are a set, not an either/or. The privacy question carries an "I need to check with:" field — because the brief acknowledged storage tier wasn't picked, the skill 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.

You copy the JSON. You open omgfixmd.com in a tab. You paste. The site renders four questions on a form. You answer them 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 form beats a checklist

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 form is different. Each question ends in radio buttons. 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 copy into a Claude conversation right now. Each one fires the skill in 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 omgfixmd.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 question-extractor 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. /question-extractor — figure out what's still undecided and hand me a form.

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 omgfixmd. 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 omgfixmd, 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 omgfixmd 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

One file. Drop question-extractor.md into your Claude project's skills directory (or wherever your Claude setup loads SKILL files from). Current version is 1.2; the JSON output carries the version it was generated against, so omgfixmd.com tells you when your installed copy is stale and offers a one-click upgrade prompt.

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 OMGfixMD exists. The chat box also can't force the unanswered questions in a brief to surface as a checklist — which is why this skill exists. Same diagnosis, opposite direction. The arrow that points at the answer is the OMGfixMD product; the arrow that points back through the question is this skill. Both end on the same form.