Ask a model a tricky question and demand an immediate answer: it will improvise one, confidently. Ask it to lay out its reasoning first, then conclude — and accuracy on logic, math and multi-step problems jumps. That’s chain of thought (CoT). Fair warning: unlike every other pattern in this section, this one increases your token bill on purpose. The question is when it buys more than it costs.

The analogy

“Show your work” on a math test. The student forced to write the intermediate steps catches their own error at step 2 — the one answering directly compounds it silently. Also useful for the teacher: when the answer is wrong, you can see where it went wrong.

The principle

DIRECT:  "A laptop costs €1,200 excl. VAT (21%). With a 15%
          discount applied after VAT, what's the final price?"
          → one number, take it or leave it.

CoT:     Same question +
          "Reason step by step: compute VAT first, then the
           discount. Show each step, then give the final price
           on one line starting with ANSWER:"
          → ① 1200 × 1.21 = 1452  ② 1452 × 0.85 = 1234.20
            ANSWER: €1,234.20

• The reasoning happens in the output: generating the steps is what improves the conclusion — a model can’t “think silently” in one pass, it computes by writing.
• Structure the end (“finish with ANSWER: on one line”) so downstream code can parse the conclusion without wading through the reasoning.
• A wrong answer becomes debuggable: the trace shows whether it misread the question or fumbled step 3.

One honest caveat

Modern reasoning models do this natively — they “think” internally before answering, and asking them to “reason step by step” adds little. CoT as a prompting trick matters most on standard models, small local models, and anywhere you want the reasoning visible and auditable.

💶 The token payoff

This is the pattern’s honest trade-off, in plain numbers:

• CoT costs more per call: the reasoning is output tokens — the expensive kind, often 3–5× input price. A 300-token reasoning trace is real money at scale.
• It pays when errors are dearer than tokens: a wrong amount on an invoice, a bad eligibility decision, a miscalculated dosage window. One avoided error usually buys thousands of reasoning tokens.
• It saves the retry spiral: a confidently wrong direct answer triggers “that’s wrong, try again” round-trips that re-bill the whole context — often costing more than the reasoning would have.
• Don’t pay it everywhere: for classification, extraction or formatting, CoT is waste. Route the hard cases to a CoT prompt and let the easy 80% answer directly.

The classic trap

Trusting the story. A reasoning trace reads rigorous, but a model can write five impeccable-looking steps and still smuggle in a wrong number — plausible text, remember, not verified truth. CoT improves the odds; it is not a proof. For anything load-bearing, verify the conclusion with real code or an evaluator that actually recomputes.