Step-Back Prompting (Ask the Bigger Question First)

TL;DR: Step back prompting has the model answer a bigger, more general question before it answers yours. It is a technique from a 2023 Google DeepMind paper published at ICLR 2024: ask for the underlying principle first, then reason from that principle to the specific answer. It measurably beats chain-of-thought on physics, historical-knowledge, and multi-hop reasoning questions.

What is step back prompting?

Step back prompting (the paper itself writes it Step-Back Prompting) is a two-step technique: before the model answers your actual question, you have it answer a bigger, more general question first, then reason from that answer to yours.

It comes from "Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models", submitted to arXiv in October 2023 by Huaixiu Steven Zheng, Swaroop Mishra, Xinyun Chen, Heng-Tze Cheng, Ed H. Chi, Quoc V. Le, and Denny Zhou at Google DeepMind, and later accepted at ICLR 2024. In the authors' own words, the technique "enables LLMs to do abstractions to derive high-level concepts and first principles from instances containing specific details." Using those principles to guide reasoning lets the model "significantly improve" at following a correct path to the answer.

The paper opens with a line from Edsger Dijkstra that does most of the explaining in one sentence: "The purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise." Stepping back is not hedging. It is choosing a higher altitude from which the specific question becomes easier to answer correctly.

The headline numbers, quoted directly from the paper's abstract: step-back prompting "improves PaLM-2L performance on MMLU (Physics and Chemistry) by 7% and 11% respectively, TimeQA by 27%, and MuSiQue by 7%." Those are not small effects for a technique that costs one extra sentence.

How does step back prompting actually work?

Two steps, and the paper names them plainly.

Abstraction. "Instead of addressing the question directly, we first prompt the LLM to ask a generic step-back question about a higher-level concept or principle, and retrieve relevant facts about the high-level concept or principle."

Reasoning. "Grounded on the facts regarding the high-level concept or principle, the LLM can reason about the solution to the original question."

The paper's own two worked examples make the shape concrete. Take a physics question about an ideal gas: what happens to the pressure if temperature doubles and volume increases eightfold. Reasoned on directly, the model can lose track of which term goes where. Asked to step back first, with a prompt shaped like "What are the physics principles behind this question?", it retrieves the ideal gas law, PV = nRT, and then substitutes correctly, because the answer is now anchored to a formula instead of floating free in the specific numbers.

The second example swaps a formula for a fact. The original question asks which school a historical figure, Estella Leopold, attended during a specific four-month window in 1954. Answered directly, a model has to reason about a narrow date range with no anchor. Stepped back, the question becomes "What was Estella Leopold’s education history?", a question the model can actually answer from what it knows, degree by degree, school by school. Once that timeline exists, placing one four-month window inside it is comparatively easy.

That is the whole mechanism, and the paper states the underlying bet directly: "The premise is that the step-back question is typically much easier." You are not making the model do more work. You are making it do a different, easier piece of work first, so the hard piece has something solid to stand on.

What do the actual numbers say?

Here is Table 1 from the paper, comparing plain prompting, chain-of-thought prompting, Take a Deep Breath prompting (a rival zero-shot instruction the paper tests as a baseline, credited to Yang et al., 2023), and step-back prompting, across three model families on MMLU high-school Physics and Chemistry:

Source: Zheng et al., "Take a Step Back" (arXiv:2310.06117), Table 1, arxiv.org/abs/2310.06117, accessed 3 September 2026.

Step-back prompting is the best-performing method in every single row. Notice, too, that plain chain-of-thought sometimes underperforms the do-nothing baseline (PaLM-2L Physics drops from 66.4% to 65.0% under CoT). On a task this reasoning-heavy, narrating the steps without a correct principle to narrate from does not help, and can hurt. The paper describes the cross-model result plainly: it calls step-back prompting "model-agnostic." That means the two-step shape helped across PaLM-2L, GPT-4, and Llama2-70B, even though the size of the gain differs by model and by how much headroom each baseline had left.

How do you write a step back prompt?

Two working shapes, depending on whether you want two turns or one.

Two-message version. Ask the abstraction question first, read the answer, then ask the real question with that answer already in context. This is closest to how the paper actually ran the technique, and it is the version to use when the principle is worth checking before you rely on it.

Message 1:
Before I ask my real question, answer this: what is the general
principle, law, or piece of background knowledge someone would need
to correctly answer a question about [topic]?

Message 2 (after reading the answer):
Using the principle above, now answer: [your original, specific question]

Single-message version. Fold both steps into one instruction when you want a single round trip. This is closer to a template you would save in a prompt library and reuse.

Step 1 (Abstraction): Before answering, state the general principle,
formula, or background fact that governs this kind of question.

Step 2 (Reasoning): Using only what you stated in Step 1, reason
through and answer the specific question below.

Question: [your original, specific question]

Either version works from the paper's own core finding: you do not need a library of examples to make this land. A single demonstration of a question paired with its underlying principle was enough in testing, and piling on more worked examples past that first one produced no further gain on the benchmark the paper measured it against. That is good news if you want to reuse this as a template rather than hand-craft it per question: one clean example of the abstraction step, reused, is doing almost all of the work.

When does stepping back help, and when does it just add a step?

Match the technique to the shape of the question, not to every question.

It helps when the specific question sits on top of something more general: a physics or chemistry formula, a person's full timeline, a broader body of facts the model has to narrow down from. The paper's own task selection makes the pattern explicit: it tested STEM (MMLU Physics and Chemistry), knowledge QA with time-sensitive or situational constraints (TimeQA, SituatedQA), and multi-hop reasoning (MuSiQue, StrategyQA). All three categories share one property: getting a general fact or principle wrong at the start guarantees the specific answer is wrong too.

It adds nothing, and just costs you a round trip, when there is no principle to retrieve. A translation has no underlying law. A short rewrite has no timeline to reconstruct. A single-fact lookup (a plain "what year did X happen" with no reasoning required) does not benefit from asking a bigger question first, because there is no bigger question that makes the small one easier. Save the technique for the questions where the model's failure mode is that it wandered into the wrong formula, or missed a fact that would have made the question obvious, rather than simply not knowing the fact at all.

Step back prompting vs. asking ChatGPT to ask you questions first

These sound similar and point in opposite directions.

Getting ChatGPT to ask you questions first has the model interview you: it identifies gaps in what you told it, and asks you to fill them before it starts. The missing information lives in your head, not the model's, and the fix is a clarifying question aimed outward.

Step-back prompting never leaves the conversation. The model asks and answers its own more general question, using facts and principles it already has, before it reasons about your specific question. The missing piece was never something only you knew: it was a principle the model already knew but had not been prompted to retrieve first. Nothing gets sent back to you. The model steps back, then steps forward again, on its own.

Put simply, one technique closes gaps in your prompt, and the other closes gaps in the model's own path to the answer. They compose fine together (you can interview the user for context, then have the model step back to a principle before reasoning), but they are solving different problems, and neither substitutes for the other.

How does step back prompting relate to analogical prompting and self-ask?

Both are close cousins in the same family of technique, having the model do a preparatory step before the real one, and both ship alongside this post.

Analogical prompting has the model generate its own relevant worked examples before tackling your actual problem: it reaches for a precedent, a similar solved case, rather than a general principle. Step-back prompting reaches upward, toward an abstraction; analogical prompting reaches sideways, toward an analogous instance. Use step-back when the question sits under a law or a fact. Use analogical prompting when it sits closer to a pattern the model has seen worked out before, such as a coding problem or a proof technique.

Self-ask has the model break your question into a chain of smaller sub-questions, answering each one in sequence before combining them into a final answer. That is decomposition into parts. Step-back prompting is the opposite move: one question, broader than the original, answered once. If your task genuinely splits into sequential sub-questions, self-ask fits better. If it sits on top of one general principle, step-back does.

A worked example: applying the two-step shape yourself

Say you already have a prompt like this, which asks a model to reason about something specific with no anchor supplied:

Our support ticket volume in the EU region jumped 40% after we
changed our refund window from 30 days to 14 days. Is the policy
change the cause, or should I look elsewhere first?

Reasoned on directly, a model has to guess at what else could plausibly move ticket volume, without a structure to check candidate explanations against. Applying the two-step shape means adding an abstraction step ahead of the real question:

Step 1 (Abstraction): Before answering, list the general categories of
explanation for a step change in support ticket volume for a company
(policy changes, seasonality, an outage or bug, a marketing push, a
pricing change, a competitor event).

Step 2 (Reasoning): Using that list as a checklist, reason through
which of those categories plausibly explain a 40% jump in EU ticket
volume that coincided with a refund-window change from 30 to 14
days, and what you would check to confirm or rule out each one.

I have not run either version against a live model to produce a side-by-side transcript for this post. The paper's own reported gains come from its controlled benchmark runs, not from this example, and I am not claiming a number for a query I did not make. What the two-step shape reliably changes, based on the mechanism the paper documents, is the checklist forcing the model to consider causes it might otherwise skip straight past on the way to the most obvious one.

Make it a habit, not a one-off

The templates above are worth keeping somewhere you will actually reach for them, because retyping the abstraction step from memory is how it quietly turns back into plain chain-of-thought. A short, reusable version of the abstraction step, along the lines of "state the general principle or category this falls under before you reason", belongs next to your other saved prompts, alongside the interview line from post 154 and the decomposition prompt from self-ask, so you reach for the right one instead of whichever you remember first.

If you are building out a fuller prompting toolkit rather than one technique at a time, how to write better ChatGPT prompts is the wider foundation this sits on top of. Prompt Architects keeps techniques like this one, alongside your other saved prompts, synced across ChatGPT, Claude, Gemini, and the other platforms the extension supports, so the exact wording that works is one click away instead of a half-remembered rewrite.