Self-Ask Prompting: 4 Recipes That Ship (2026)
Self-ask prompting in 2026: four copy-paste recipes that make a model ask and answer its own follow-up questions, plus the search-tool upgrade and the gate for when to skip it.
On this page
Quick answer (2026): Self-ask prompting makes a model ask and answer its own follow-up questions before it commits to a final answer. It targets the compositionality gap: the model that knows every sub-fact but still fumbles the multi-hop question (the self-ask paper, Press et al., 2022). Below are four copy-paste recipes, the search-tool upgrade, and the gate for when to skip it. All tested October 2026.
Self-ask is a stricter cousin of chain-of-thought: same idea, named slots instead of loose "let's think step by step" prose. The named slots are the whole point. They make the model commit each hop to text, and they make the output parseable.
Recipe 1: the scaffold (one message)
Claim: force the follow-up structure and multi-hop answers stop skipping steps.
Answer the question. If it needs more than one fact, decompose it first.
Use exactly this format:
Question: (the user question)
Are follow up questions needed here: Yes or No.
Follow up: (a sub-question)
Intermediate answer: (answer to that sub-question)
Follow up: (next sub-question)
Intermediate answer: ...
So the final answer is: (final answer)
Question: Who was US president when the company that makes the iPhone was founded?
Why it works: the format is documented straight from the self-ask paper (Press et al., 2022). The literal prefixes "Follow up:", "Intermediate answer:", and "So the final answer is:" force each step into text before the next, so the model cannot silently skip a hop. Grep the last line after "So the final answer is:" and you have a clean answer to return.
Failure mode: on a one-hop lookup the model still pads two fake follow-ups. Keep the "Are follow up questions needed here: No" branch so it can bail straight to the answer.
Recipe 2: self-ask plus search (plug a tool into the follow-up slot)
Claim: the parseable format is what lets you swap the model's guessed intermediate answer for a real one.
The weakest link is the model's own "Intermediate answer:" lines. It guesses facts. So stop generation at each one, run your own search or retrieval on the preceding "Follow up:" question, paste the real result back, and resume.
loop:
generate until the next "Intermediate answer:" line
read the text of the last "Follow up:" question
call your search or RAG tool with that question
write the tool result as the "Intermediate answer:" line
resume generation
stop when the model emits "So the final answer is:"
Why it works: Press et al. (2022) showed that plugging a search engine into exactly this slot lifts accuracy on multi-hop questions, because the retrieved fact replaces a hallucinated one at each hop. Any retrieval you already have works. You can prefill the reply with the first three format lines to lock the structure before the loop starts.
Failure mode: a loose parser feeds the tool a malformed query. Anchor on the literal "Follow up:" prefix, one question per line, and trim everything after the question mark.
Recipe 3: the gate (when to skip self-ask)
Claim: self-ask is latency and tokens you do not always need.
First line only. Answer DIRECT if this needs one lookup or one step.
Answer DECOMPOSE if it needs chaining two or more facts. Then stop.
Question: (the question)
Route DIRECT questions to a plain call. Send DECOMPOSE ones through Recipe 1.
Why it works: self-ask helps multi-hop composition. On single-fact lookups, formatting, or rewriting it adds cost and can inject a wrong intermediate answer into a task that needed none.
Failure mode: borderline questions. Default to DIRECT. A wrong DIRECT is cheap, a wrong DECOMPOSE burns tokens on questions that never needed decomposing.
Recipe 4: self-ask for debugging (no tool, one call)
Claim: the same follow-up structure rubber-ducks a bug without a chat session.
You are debugging. Before proposing any fix, self-ask.
Follow up: what is the smallest input that reproduces this?
Intermediate answer: ...
Follow up: which layer owns the failing value (input, transform, or output)?
Intermediate answer: ...
Follow up: what would have to be true for the current output to be correct?
Intermediate answer: ...
So the likely cause is: ...
Minimal fix: ...
Bug: (paste the error and the code)
Why it works: naming the sub-questions first stops the model jumping to a plausible but wrong patch. It has to locate the fault before it edits anything.
Failure mode: the model can answer its own follow-ups confidently and wrongly, same as any single-model reasoning. Treat "likely cause" as a hypothesis to check, not a verdict.
Ship it
Start with Recipe 1. Add Recipe 3 as a router the moment you start sending it lookups. Add Recipe 2 the moment multi-hop accuracy matters more than latency. Both major providers document this family of structured-reasoning prompts: see Anthropic's prompting docs and OpenAI's prompting guide.
Tested on Claude 
, October 2026.
Cost to test: about $0.01 a call.
Written by
Sam Q.Sam Q. writes terse, tested prompt recipes for PromptAttic. Claim, receipt, why, failure mode, ship.
FAQ
What is self-ask prompting?
Self-ask prompting is a reasoning technique where the model explicitly asks and answers its own follow-up sub-questions before it gives a final answer. It was introduced by Press et al. in 2022 to close the compositionality gap: cases where a model knows every sub-fact but still gets the multi-hop question wrong.
How is self-ask prompting different from chain-of-thought?
Chain-of-thought asks the model to reason in free-form prose. Self-ask uses named, parseable slots (Follow up:, Intermediate answer:, So the final answer is:) that force one explicit sub-question and sub-answer per hop. The rigid format is what makes self-ask easy to parse and easy to hook a search tool into.
What is the self-ask format?
A single message that instructs the model to output: an Are-follow-up-questions-needed line (Yes or No), then repeated Follow up: and Intermediate answer: pairs, and finally a So the final answer is: line. You then read the text after the final line as the answer.
What is self-ask plus search?
Self-ask plus search stops generation at each Intermediate answer: slot, runs your own search or retrieval on the preceding Follow up: question, and pastes the real result back before resuming. Press et al. (2022) showed this raises accuracy because a retrieved fact replaces a hallucinated one at each hop.
When should you not use self-ask prompting?
Skip it on single-fact lookups, formatting, and rewriting. Self-ask helps multi-hop composition; on one-step tasks it adds latency and tokens and can inject a wrong intermediate answer. Gate it with a first-line DIRECT-or-DECOMPOSE classifier and only decompose when two or more facts must be chained.
Does self-ask prompting work with Claude and GPT?
Yes. Self-ask is a plain-text prompting pattern with no model-specific API, so it works on Claude, GPT, and other instruction-following models. Both Anthropic and OpenAI document structured-reasoning prompting in their prompt-engineering guides.
Related recipes
Chain of Thought Prompting: 6 Examples That Ship (2026)
Five paste-ready chain-of-thought prompting examples for 2026, each with its failure mode, plus when reasoning out loud makes the answer worse.
Assistant Prefill: 4 Recipes That Ship (2026)
Assistant prefill in 2026: four copy-paste recipes that force JSON, kill the preamble, lock the output shape, and hold a persona, plus where prefill breaks.
Chain of Verification: A Prompt That Catches Its Own Hallucinations (2026)
Chain of Verification (CoVe) is a four-step prompt that cuts hallucinations by making a model draft, plan verification questions, answer them independently, and rewrite keeping only what survived.