Plan-and-solve prompting: a complete guide

Zero-shot chain-of-thought has a quiet failure mode: you tell a model "Let's think step by step," and it skips a step. Plan-and-Solve (PS) prompting fixes that by splitting the work in two — first make the model write a plan, then make it execute the plan. That one change pushes a zero-shot model up to 91.8% on MultiArith and 59.3% on GSM8K, close to an 8-shot hand-built chain-of-thought, with no examples at all (Wang et al., ACL 2023).

See it work

Here's the slip that motivates the whole technique. Same model, same problem, two prompts.

Problem: A bookstore has 120 books. On Monday it sells 25% of them.
On Tuesday it sells 30 more. On Wednesday a shipment doubles the
stock it has left. How many books does it have now?

Zero-shot-CoT ("Let's think step by step"):
25% of 120 is 30, so 90 books are left.
Wednesday doubles that: 90 × 2 = 180.
The answer is 180.

It dropped Tuesday entirely — a textbook missing-step error. Now the same problem with PS+:

A: Let's first understand the problem, extract the relevant variables
and their numerals, and devise a plan. Then carry out the plan.

Variables: start = 120, Monday sold = 25%, Tuesday sold = 30, Wednesday = ×2 on remainder.

Plan:
1. Monday's sales, then remainder.
2. Subtract Tuesday's 30.
3. Double Wednesday's remainder.

Execution:
1. 25% × 120 = 30 sold → 90 left.
2. 90 − 30 = 60 left.
3. 60 × 2 = 120.

The answer is 120.

The plan forced the model to enumerate all three days before it started calculating, so step two couldn't vanish.

The mental model

Think of a contractor who sketches a blueprint before pouring concrete. The sketch isn't the building — but it's a checklist that makes sure no room gets forgotten. PS prompting makes the model draw the blueprint first.

Standard CoT discovers the steps as it writes. Plan-and-Solve commits to the steps before it writes, so it can't quietly skip one.

The research framing is just as plain: "Let's think step by step" tells the model to reason but not how. PS replaces that vague trigger with an explicit instruction to understand, plan, then execute — mirroring how expert problem-solvers spend more time framing a problem before touching it.

How it works

It runs as a single forward pass — the plan and the execution come out of one inference, not two API calls:

1. Understand — restate what's asked, note the givens and constraints.
2. Extract variables — pull out the numbers and what they mean (this is the PS+ addition).
3. Plan — break the task into ordered subtasks and note their dependencies.
4. Execute — work the plan, calculating each intermediate result explicitly.
5. Answer — combine results and state the final answer in a parseable form ("The answer is …").

Why it works

The gains aren't magic; they trace to a few specific effects, roughly in order of how much they move the needle.

Two mechanisms do the heavy lifting. Explicit planning identifies every step upfront, so the model is less likely to skip one mid-stream. And explicit variable extraction creates a little bookkeeping ledger, which keeps a bad intermediate calculation from quietly propagating into the final answer.

Where it shines

PS is built for multi-step reasoning where the path is decomposable: arithmetic word problems, algebra, percentage and ratio chains, and any task where later steps depend on earlier results. It also carries over to logical and symbolic tasks (last-letter concatenation, coin-flip state tracking) and to commonsense multi-hop questions.

The headline result from Wang et al. is that PS+ matches few-shot manual CoT without any examples. On arithmetic:

On commonsense and symbolic reasoning the pattern holds, and on Last Letters PS+ actually beats the 8-shot baseline:

Across all 10 datasets PS+ beats Zero-shot-CoT by about 2.5% on average (GSM8K alone improves 2.9%), and its average accuracy of 76.7% lands just shy of manual CoT's 77.6% — while needing zero examples.

The error analysis explains which mistakes it fixes. Wang et al. hand-labeled 46 wrong GSM8K answers from Zero-shot-CoT into three buckets, then re-ran with PS+:

PS+ nearly halves missing-step errors and dents calculation errors, but it does nothing for semantic misunderstanding — the model misreading what the problem asks. That gap is the technique's defining limitation, and it's why semantic errors stay the largest category.

When to use it (and when not)

Reach for PS when the problem is multi-step with clear sequential structure, calculation accuracy matters, you have no examples to spend on few-shot, and you've seen Zero-shot-CoT drop steps.

Skip it when the task is a single-step lookup or classification, when it's creative or open-ended (rigid planning gets in the way), or when the real bottleneck is comprehension rather than missing steps — PS won't help there.

Model fit. PS leans on instruction following and multi-step reasoning, so it scales with capability. Treat 7B as a rough floor where results get inconsistent; 70B-class or GPT-3.5-and-up is a safer recommendation, and GPT-4 / Claude-class models give the cleanest plans. Smaller open-source models are hit-or-miss — some regress relative to plain Zero-shot-CoT, so test before you commit.

When PS isn't enough, escalate:

And pick the variant to match the job:

The prompt

There are three triggers, escalating from terse to thorough. The problem goes after Q:, the trigger after A:.

Basic PS:
Let's first understand the problem and devise a plan to solve the problem.
Then, let's carry out the plan and solve the problem step by step.

PS+ (adds variable extraction and calculation attention):
Let's first understand the problem, extract relevant variables and their
corresponding numerals, and devise a plan. Then, let's carry out the plan,
calculate intermediate results (pay attention to calculation and commonsense),
solve the problem step by step, and show the answer.

Minimal (token-constrained):
Let's devise a plan and solve the problem step by step.

The difference between basic and PS+ is the whole game: "extract relevant variables and their corresponding numerals" plus "pay attention to calculation and commonsense" are the two clauses that buy the accuracy bump. For a domain, swap in domain-specific language — physics gets "extract variables, their values, and their units… pay attention to unit consistency"; finance gets "extract financial variables (prices, rates, periods)… pay attention to percentage calculations."

Building it

The core is two functions: build the prompt, then parse the answer out of the response.

import re

TRIGGERS = {
    "basic": "Let's first understand the problem and devise a plan to solve the "
             "problem. Then, let's carry out the plan and solve the problem step by step.",
    "ps+":   "Let's first understand the problem, extract relevant variables and their "
             "corresponding numerals, and devise a plan. Then, let's carry out the plan, "
             "calculate intermediate results (pay attention to calculation and "
             "commonsense), solve the problem step by step, and show the answer.",
    "minimal": "Let's devise a plan and solve the problem step by step.",
}

def construct_ps_prompt(problem: str, variant: str = "ps+") -> str:
    return f"Q: {problem}\n\nA: {TRIGGERS[variant]}"

def extract_answer(response: str):
    for pattern in (r"[Tt]he answer is[:\s]*([^\.\n]+)", r"####\s*([^\n]+)"):
        m = re.search(pattern, response)
        if m:
            return m.group(1).strip()
    return None

Wiring that to a model is a thin wrapper. Keep the temperature low — planning wants consistency, not creativity.

import anthropic

client = anthropic.Anthropic()

def ps_solve(problem: str, variant: str = "ps+") -> str:
    message = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=1024,
        messages=[{"role": "user", "content": construct_ps_prompt(problem, variant)}],
    )
    return message.content[0].text

For high-stakes answers, wrap PS in self-consistency: sample several times and take the majority vote. This is how you prove a noisy answer is actually stable.

from collections import Counter

def ps_with_consistency(problem: str, n_samples: int = 5):
    answers = [a for a in (extract_answer(ps_solve(problem)) for _ in range(n_samples)) if a]
    return Counter(answers).most_common(1)[0][0] if answers else None

Configuration

Rough token budget: minimal triggers run ~40 prompt tokens, basic PS ~60, PS+ ~90, with 100–300 tokens of reasoning on top (150–400 for PS+).

Do and don't

• Do use PS+ for calculation-heavy tasks, keep temperature low, allow enough tokens for a complete response, and parse-then-validate the extracted answer.
• Don't use it on single-step problems, don't expect it to fix semantic misreads, don't run high temperature (it undermines the planning), and don't truncate mid-reasoning.

When it misbehaves

Limitations

Three of these are fundamental, not tuning problems:

• Semantic misunderstanding is untouched. If the model misreads the question, no amount of planning saves it — error analysis shows semantic errors flat at 27% with both Zero-shot-CoT and PS+.
• Planning can't supply missing knowledge. If the model doesn't know the formula, a plan to use it doesn't help.
• It amplifies, it doesn't create. PS surfaces reasoning a model already has; a model that can't reason won't suddenly reason because you asked for a plan.

Follow-up work like DUP (Zheng et al., 2024) targets exactly that semantic-understanding gap, pushing the model to deeply understand the problem before planning — a complementary attack on the one error category PS leaves untouched.

Beyond those, watch the edges: ambiguous problems get planned for one interpretation without flagging the others; circular dependencies between steps can stall planning; and very large numbers degrade arithmetic accuracy regardless of structure.

Advanced and adjacent

A few extensions earn their keep without changing the core idea. Adding an explicit verification phase ("after finding an answer, recheck the calculations and that the answer satisfies all constraints") catches arithmetic slips. Structured output — asking for distinct Understanding / Variables / Plan / Execution / Answer sections, or JSON — makes responses trivially parseable for pipelines. And self-consistency (above) trades tokens for reliability on high-stakes calls.

PS has also seeded a small family of techniques. Self-Planning adapts plan-before-execute to code generation; MSG (Multi-Stage Guided) extends it to multi-phase code planning; QDMR-based variants pair PS with question-decomposition representations. LangChain ships a Plan-and-Execute agent built directly on PS principles, and the official reference implementation lives at the AGI-Edgerunners/Plan-and-Solve-Prompting repository.

How it relates to the neighbors

A compact head-to-head:

PS combines naturally with other methods too — self-consistency for reliability, RAG for knowledge-intensive tasks (plan-guided retrieval), tool use (the plan incorporates tool calls), and verification passes.

Future directions

The open questions are about granularity and transfer: what level of plan detail maximizes accuracy without overhead, whether triggers tuned for one domain transfer to another, and how to measure plan quality separately from execution quality. Active threads include automated trigger optimization (learning the best PS phrasing per domain), hierarchical planning where high-level steps contain sub-plans, multi-agent PS that splits planning and execution across models, and how plan-then-execute interacts with native reasoning models like the o1/o3 line.

Summary

• Plan-and-Solve splits reasoning into plan-then-execute, replacing "Let's think step by step" with an explicit instruction to understand, plan, then carry out the plan.
• PS+ adds variable extraction and calculation attention — those two clauses are what close most of the gap to few-shot CoT.
• It mainly kills missing-step and calculation errors (missing steps down 41.7%, calculation down 28.6% on GSM8K) but does nothing for semantic misunderstanding.
• It matches 8-shot manual CoT with zero examples — 91.8% MultiArith, 59.3% GSM8K, 76.7% average across ten datasets (Wang et al., ACL 2023).
• Use it for multi-step, calculation-heavy, example-free problems; skip it for single-step, creative, or comprehension-bound tasks.
• Keep temperature low, allow room for the full plan, parse the answer explicitly, and escalate to self-consistency, few-shot, or Tree of Thoughts when PS plateaus.