PromptCause
Donate

2 / 11

Reasoning

Chain-of-Thought, CoT

Intermediate

In short: Ask for step-by-step reasoning BEFORE the answer.

What is: Have the model write its reasoning in steps before concluding, instead of jumping straight to the answer. It's the single most important reasoning technique.

When to use: Math, logic, decisions with trade-offs, hard classification.

When to avoid: On reasoning models (OpenAI o-series, GPT-5 reasoning): they already reason internally and asking for "step by step" can even hurt. On Claude with thinking off, prefer "analyze/assess", the word "think" is sensitive.

Wrong
A product costs $80. With 15% off then 8% tax, what's the final price? Answer with the number only.
Right
A product costs $80, with 15% off then 8% tax on the discounted amount. Reason step by step in <calc>, then give the value in <answer>.

Showing each operation drastically reduces arithmetic errors.

Why: Writing the reasoning creates "thinking space" before the answer. In the original paper (Wei et al., 2022), CoT raised math-reasoning accuracy from ~18% to ~57% on large models.

💡 Tip: Separate the reasoning (<thinking>) from the final answer (<answer>) so you use the thinking without polluting the output.

Zero-shot CoT

Intermediate

In short: Just add "think step by step", no examples.

What is: The simplest version of CoT: append a phrase like "Let's think step by step" without providing reasoning examples.

When to use: When you want the CoT gain without building examples.

When to avoid: On reasoning models (they reason on their own). On Claude without thinking, swap "think" for "consider/analyze".

Wrong
João is twice Maria's age. Together they sum 36. Maria's age?
Right
João is twice Maria's age. Together they sum 36 years. What is Maria's age? Let's solve it step by step.

The phrase is enough for the model to set up the equations instead of guessing.

Why: Kojima et al. (2022) showed that just "Let's think step by step" raised GSM8K accuracy from 17.7% to 78.7%, with no examples at all.

💡 Tip: It's practically free. If the task is even slightly analytical, it's always worth a try.

Step-back prompting

Intermediate

In short: Step back to a general principle before solving the case.

What is: Before attacking the specific problem, ask the model to state the general concept or rule. Then it applies that rule to the case.

When to use: Problems where applying the right rule matters more than computing, physics, law, diagnosis.

When to avoid: On direct, simple tasks it adds steps with no gain.

Wrong
A gas at 2 atm and 300K is heated to 600K at constant volume. What's the new pressure?
Right
First, which gas law applies when volume is constant and temperature changes? State the relation. Then apply it: 2 atm, 300K → 600K.

Anchoring on the right law (Gay-Lussac) avoids mixing formulas.

Why: Stepping back to a principle reduces premise errors, the model solves from the correct concept, not a shallow association.

💡 Tip: Combine with CoT: state the principle, then reason step by step on the application.

Plan-and-Solve

Intermediate

In short: Plan first, execute after.

What is: An improvement on "think step by step": ask the model to FIRST draft a plan and THEN execute. Reduces the error of skipping steps.

When to use: Multi-step tasks where simple "step by step" sometimes forgets parts.

When to avoid: Single-step tasks, the planning becomes bureaucracy.

Wrong
Plan a 3-day trip to Lisbon thinking step by step.
Right
Plan a 3-day trip to Lisbon. First draft a plan (dimensions: lodging, transport, attractions, budget, meals). Then execute, filling each dimension day by day.

Listing the dimensions first ensures coverage, it won't forget the budget.

Why: Separating planning from execution reduces the "getting lost on the way" error. Wang et al. (2023) showed a consistent gain over plain zero-shot CoT.

💡 Tip: Ask for the plan as a list before execution, easy to review and course-correct.

Self-Consistency

Advanced

In short: Solve several times and go with the majority answer.

What is: Run the same CoT prompt several times (with randomness) and pick the answer that appears most often. Like polling several experts and following the consensus.

When to use: Critical problems where a single chain can slip and you can afford N runs.

When to avoid: Simple or cost-sensitive tasks, it costs N× tokens.

Right
Solve this problem in 3 independent ways, each with full reasoning. Then compare the three conclusions and answer with the value at least two agree on.

Reasoning errors tend to be random; correct answers converge.

Why: Wang et al. (2022) showed that sampling and voting raised GSM8K accuracy by +17.9 points over plain CoT. The consensus filters out random slips.

💡 Tip: Even in a single call, ask for "3 independent approaches + majority vote" for a similar effect at lower cost.

Self-check (verification)

Intermediate

In short: Ask the model to check its own answer before delivering.

What is: Add a step where the model verifies the answer against a criterion before finishing. Cheap and effective.

When to use: Almost always when the answer is verifiable, code, math, extraction.

When to avoid: When there's no objective verification criterion, it's just more text.

Wrong
Write a function that validates a CPF.
Right
Write a function that validates a CPF. Before finishing, mentally test it with a valid one, an invalid one and one with letters, and fix any case that fails.

Self-verification catches the "letters in input" case that would be forgotten.

Why: Forcing verification moves the model out of "generator mode" into "reviewer mode", which sees errors the generator doesn't.

💡 Tip: Give explicit verification criteria ("test with X, Y, Z"), vague verification catches little.

Reflexion / Self-Refine

Advanced

In short: Generate, critique your own answer, and redo it better.

What is: A loop: the model generates, CRITIQUES its own answer pointing out concrete flaws, then produces a revised version. Stronger than self-check (which is just verification).

When to use: Code, writing, sequential reasoning, tasks where the 1st try usually has fixable errors.

When to avoid: When the first answer is already good and simple, the loop only adds cost.

Right
1. Write the landing page copy. 2. Critique your own copy: does the headline hook? is the value prop clear? is there a single CTA? List each flaw. 3. Rewrite fixing the flaws you listed.

Self-critique forces the shift from "generator mode" to "editor mode".

Why: Shinn et al. (2023) showed the self-reflection loop improves performance on decision, coding and reasoning tasks, version 2 is almost always better than version 1.

💡 Tip: Give concrete criteria for the critique; a generic "improve it" yields cosmetic changes.