Beyond zero-shot and few-shot: chain-of-thought, self-consistency, tree of thoughts, ReAct, decomposition, and meta-prompting — with the foundational research, copyable patterns, the cost/latency trade-offs, and why reasoning models change when to use them.
By The DDH Team at Digital Dashboard Hub·Updated
Advanced prompt engineering is mostly about reasoning structure: making the model think in steps, explore alternatives, use tools, or break a hard problem into smaller ones — and knowing when each is worth its extra cost and latency. The headline techniques are chain-of-thought, self-consistency, tree of thoughts, ReAct, task decomposition, and meta-prompting, each with research behind it.
This guide assumes you already know the basics (if not, start with our Complete Guide to Prompt Engineering). Here we go technique by technique with citations to the foundational arXiv papers and the DAIR.ai Prompt Engineering Guide, copyable patterns, and an honest read on trade-offs — including the important 2026 caveat that reasoning-tuned models now do much of this internally.
Digital Dashboard Hub
Writing good prompts for ONE AI is hard. Writing them for GPT-5, Claude, Gemini, Perplexity, Midjourney and 6 more is a full-time job. DDH's AI Prompt Builder writes once, runs everywhere — locked to your niche, voice, and brand tone.
Free 14 days, no card. →
| Feature | What it does | When to use it | Relative cost | Primary source |
|---|---|---|---|---|
| Chain-of-thought | Step-by-step reasoning before the answer | Everyday multi-step reasoning | Low–medium | Wei et al. 2022 (arXiv:2201.11903) |
| Self-consistency | Sample N chains, take majority vote | High-value answers that vary run to run | High (N× calls) | DAIR.ai (CoT extensions) |
| Tree of thoughts | Explore & prune reasoning branches | Genuine search/planning problems | Very high | Yao et al. 2023 (arXiv:2305.10601) |
| ReAct | Reasoning interleaved with tool actions | Tasks needing external info/actions | Medium–high | Yao et al. 2022 (arXiv:2210.03629) |
| Decomposition / chaining | Split into focused sequential steps | Complex multi-stage work | Medium | DAIR.ai (prompt chaining) |
| Meta-prompting | Model writes/improves the prompt | Drafting & hardening prompts | Low | DAIR.ai / provider docs |
Synthesized from the linked arXiv papers and the [DAIR.ai Prompt Engineering Guide](https://www.promptingguide.ai/). Costs are relative and rise further on reasoning models that already reason internally. Always measure against a simpler baseline. Current as of June 2026.
Each section is a technique you can apply today:
1. A note on reasoning models (read this first).
2. Chain-of-thought (CoT).
3. Self-consistency (sample and vote).
4. Tree of thoughts (explore and prune).
5. ReAct (reason + act with tools).
6. Task decomposition and prompt chaining.
7. Meta-prompting (let the model write the prompt).
8. Choosing the right technique (and the cost trade-off).
9. Sources & further reading.
Many advanced techniques were developed when models did no internal reasoning by default — you had to elicit step-by-step thinking with the prompt. In 2026, reasoning-tuned models (the current top-tier OpenAI, Anthropic, and Google models) often produce extensive internal reasoning before answering, without being asked. This changes the calculus: explicit chain-of-thought adds less on these models than it did on their predecessors, and can even hurt if it overrides the model's own better reasoning.
The practical implications. On a reasoning model, try the plain prompt first — you may not need explicit CoT at all. Where these models do still benefit from prompting is in shaping what to reason about (the constraints, the success criteria, the decomposition), not in being told to 'think step by step.' And techniques that add external structure the model can't do alone — tool use (ReAct), sampling-and-voting (self-consistency), or breaking work across multiple calls (decomposition) — remain valuable regardless of how much the model reasons internally.
So read the rest of this guide as a toolkit, not a checklist. Reach for a technique when a simpler prompt provably fails, and weigh its cost. The DAIR.ai guide catalogs these patterns; what follows is when each earns its keep.
Chain-of-thought prompting asks the model to produce intermediate reasoning steps before its final answer. It was introduced by Wei et al., 2022 ('Chain-of-Thought Prompting Elicits Reasoning in Large Language Models', arXiv:2201.11903), which showed that eliciting step-by-step reasoning substantially improves performance on arithmetic, commonsense, and symbolic reasoning tasks — especially in larger models.
There are two flavors. Zero-shot CoT simply appends an instruction like 'Let's think step by step' or 'Work through this carefully before giving the final answer.' Few-shot CoT shows examples whose answers include the reasoning, so the model imitates the pattern. A minimal zero-shot CoT prompt:
``` Question: A store has 3 boxes with 12 apples each. It sells 17 apples. How many remain? Think through this step by step, then give the final number on its own line prefixed with "Answer:". ```
Use CoT for multi-step reasoning: math, multi-constraint decisions, logical deduction, debugging. The trade-off is more output tokens (cost and latency), and on reasoning models the gain is smaller because they reason internally already. A useful production pattern when you only need the answer: have the model reason, then return just the final answer in a structured field — or use a model that hides its reasoning and exposes only the conclusion.
Self-consistency improves on chain-of-thought by sampling several independent reasoning paths (using a non-zero temperature) and taking the most common final answer, rather than trusting a single chain. The intuition: if many different lines of reasoning converge on the same answer, you can trust it more; a single chain might take a wrong turn.
In practice you run the same CoT prompt N times with sampling enabled, collect the final answers, and pick the majority vote. It reliably lifts accuracy on reasoning tasks where a single chain is brittle — at a cost of N times the calls. That cost is the catch: self-consistency is expensive and slow, so reserve it for high-value answers where being right matters more than being cheap (a critical calculation, a one-off analysis), not for high-volume requests.
A note for 2026: because reasoning models already explore internally and tend to be more stable, the marginal benefit of external sampling-and-voting is often smaller than on older models — but it still helps when answers genuinely vary run to run. The DAIR.ai guide covers self-consistency among its CoT extensions. If you adopt it, also measure: compare majority-vote accuracy against a single call on your own test set before paying for it everywhere.
Tree of Thoughts (ToT) generalizes chain-of-thought from a single line of reasoning to a search over many. The model generates multiple candidate 'thoughts' at each step, evaluates them, and explores the promising branches while pruning the rest — with the ability to backtrack. It was introduced by Yao et al., 2023 ('Tree of Thoughts: Deliberate Problem Solving with Large Language Models', arXiv:2305.10601).
ToT shines on problems that require search and planning rather than a single forward pass — puzzles, constraint satisfaction, game-like planning, anything where a greedy first attempt commonly fails and you need to consider and discard alternatives. A lightweight, promptable approximation:
``` Propose 3 distinct approaches to the problem below. For each, briefly state the approach and its main risk. Then evaluate which is most likely to succeed, discard the weaker two with one-line reasons, and fully develop the chosen approach. Problem: {{problem}} ```
Be honest about cost: full ToT is the most expensive technique here because it expands many branches, each costing tokens, plus evaluation steps. Most everyday tasks do not need it. Reach for ToT only when a problem genuinely benefits from exploring and pruning alternatives and a single chain reliably fails. For the large majority of prompting, plain CoT or even a direct prompt is enough.
ReAct interleaves reasoning with actions — the model thinks, takes an action (calls a tool, runs a search, queries an API), observes the result, and reasons again, in a loop. It was introduced by Yao et al., 2022 ('ReAct: Synergizing Reasoning and Acting in Language Models', arXiv:2210.03629) and is the conceptual basis of most modern agent loops.
ReAct matters because pure reasoning can't fetch information the model doesn't have or perform actions in the world. By alternating Thought → Action → Observation, the model grounds its reasoning in real results — current data from a search, a calculation from a tool, a record from a database — instead of hallucinating them. The classic trace format:
``` Thought: I need the current price before I can compute the total. Action: get_price("SKU-441") Observation: 19.99 Thought: Now multiply by quantity 12. Action: calculate("19.99 * 12") Observation: 239.88 Thought: I have the answer. Final Answer: $239.88 ```
In production you usually implement ReAct through the provider's native tool/function-calling feature rather than parsing free text, which is more reliable. Use it whenever a task needs information or actions outside the model: retrieval-augmented answers, calculations, multi-step workflows that touch real systems. For more on agent loops built on this pattern, see our agent design patterns guide.
Decomposition means breaking a hard task into smaller sub-tasks and solving them in sequence, passing each output to the next prompt — also called prompt chaining. Instead of asking one prompt to research, outline, draft, and edit an article all at once (and getting shallow everything), you run four focused prompts, each doing one job well.
Why it works: each sub-task gets the model's full attention and a tighter, more specific instruction, and you can inspect and correct the intermediate output before it propagates. It also makes failures debuggable — when the final result is wrong, you can see which step broke. A typical chain for content: (1) extract key points from source material, (2) produce an outline from those points, (3) draft each section from the outline, (4) edit for length and tone against explicit constraints.
Decomposition pairs naturally with the other techniques — a single step in the chain might use CoT, and the whole chain might be orchestrated by a ReAct-style agent. It's also the most broadly useful advanced technique in 2026: it improves quality, controllability, and debuggability with no special model features required. Our Blog Post Outline and Code Prompt Builder are natural single links in a content or code chain.
Meta-prompting is using the model to generate or improve prompts themselves. Rather than hand-crafting the perfect instruction, you describe the task and ask the model to write a high-quality prompt for it, or to critique and rewrite a prompt you already have. It's a fast way to get a strong first draft and to discover instructions and constraints you hadn't thought of.
A useful meta-prompt:
``` You are a prompt engineer. I need a prompt that will reliably make an LLM {do the task}. Write the best prompt you can, including a clear role, explicit instructions, the output format, and constraints for handling edge cases and uncertainty. Then list 3 ways the prompt could still fail and how to harden it. ```
Meta-prompting is especially handy for unfamiliar task types and for hardening prompts before they go to production. The caveat is the same as always: the model writing the prompt is the same kind of model that will run it, so it can confidently produce a plausible-but-flawed prompt. Treat the output as a strong draft to test, not a finished artifact. Our ChatGPT Prompt Generator is meta-prompting in productized form for common tasks.
The meta-skill is matching technique to problem and not over-engineering. Start with the simplest prompt that could work; add structure only when it provably fails. Every technique here trades cost, latency, or complexity for capability, and on reasoning models several of them buy less than they used to.
A rough rule of thumb. For everyday multi-step reasoning, plain CoT (or nothing, on a reasoning model). For high-value answers that vary run to run, self-consistency. For genuine search/planning problems, tree of thoughts. When the model needs external information or actions, ReAct. For complex multi-stage work, decomposition and chaining. And meta-prompting whenever you want a strong first draft of a prompt. The table below summarizes this with the primary source for each.
Whatever you choose, measure it. Run the technique against a representative set of inputs, compare it to the simpler baseline, and only keep the added cost where it earns real accuracy. The teams that get reliable, affordable output treat advanced techniques as instruments to be justified by data — not defaults to apply everywhere.
Foundational research and guides referenced above (as of June 2026):
Chain-of-Thought (Wei et al., 2022): https://arxiv.org/abs/2201.11903
Few-shot / in-context learning (Brown et al., 2020): https://arxiv.org/abs/2005.14165
ReAct (Yao et al., 2022): https://arxiv.org/abs/2210.03629
Tree of Thoughts (Yao et al., 2023): https://arxiv.org/abs/2305.10601
DAIR.ai Prompt Engineering Guide (CoT extensions, self-consistency, ToT, ReAct): https://www.promptingguide.ai/
Learn Prompting: https://learnprompting.org/
Provider prompting docs: OpenAI https://platform.openai.com/docs/guides/prompt-engineering ; Claude https://docs.claude.com/en/docs/build-with-claude/prompt-engineering/overview ; Gemini https://ai.google.dev/gemini-api/docs/prompting-strategies
Chain-of-thought (Wei et al. 2022) walks a single line of step-by-step reasoning to the answer. Tree of thoughts (Yao et al. 2023) generates multiple candidate reasoning branches at each step, evaluates them, explores the promising ones, and backtracks — a search rather than a single pass. ToT helps on genuine search/planning problems but is much more expensive, so most tasks should use plain CoT or a direct prompt.
Often less than before. Current top-tier reasoning models from OpenAI, Anthropic, and Google produce extensive internal reasoning without being asked, so explicit 'think step by step' adds less and can occasionally hurt. Try the plain prompt first. Where these models still benefit is in shaping what to reason about — clear constraints, success criteria, decomposition — rather than being told to reason.
Self-consistency samples several independent chain-of-thought paths at non-zero temperature and takes the majority-vote answer, which is more reliable than trusting one chain. It costs N times the calls, so reserve it for high-value answers where being right outweighs cost — a critical calculation or one-off analysis — not high-volume requests. Measure majority-vote accuracy against a single call on your own test set first.
ReAct (Yao et al. 2022) interleaves reasoning with actions: the model thinks, calls a tool, observes the result, and reasons again in a loop. It grounds reasoning in real data instead of hallucinating it, and is the basis of most modern agent loops. In production, implement it through native tool/function calling rather than parsing free text. See our agent design patterns guide.
Whenever a single prompt is being asked to do several jobs at once and produces shallow results. Decomposition (prompt chaining) splits the work into focused sequential steps — e.g., extract, outline, draft, edit — passing each output to the next. Each step gets a tighter instruction, you can inspect intermediate output, and failures become debuggable. It's the most broadly useful advanced technique and needs no special model features.
Meta-prompting is using the model to write or improve prompts. You describe the task and ask the model to produce a high-quality prompt — with role, instructions, format, and edge-case constraints — or to critique one you have. It's a fast way to get a strong draft and surface instructions you missed. Treat the output as a draft to test, since the same kind of model can produce a plausible-but-flawed prompt.
The free ChatGPT Prompt Generator and Code Prompt Builder apply role, format, and reasoning structure for you — no signup, part of 40+ free prompt tools.
Browse all prompt tools →