A prompting technique that guides AI to show its reasoning steps before giving a final answer. Asking Claude to "think through it first" significantly improves accuracy on complex reasoning, math, and multi-step analysis tasks.
Full Explanation+
01 · What is this?
Chain of Thought (CoT) is a prompting technique whose core action is appending "think step by step" or a similar phrase to your question, requiring Claude to show its reasoning process step-by-step before delivering a final answer.
This technique's importance comes from a fundamental LLM behavior pattern: if you only ask "what's the answer," Claude tends to output the most probable-looking answer directly, skipping intermediate reasoning steps. For simple questions, this is fine. But for problems requiring multi-step calculation or logical reasoning, skipping steps means skipping every opportunity to verify correctness along the way — errors accumulate without detection.
CoT forces Claude to decompose the problem into verifiable sub-steps, each building on the previous. Two benefits follow: first, Claude itself is more likely to catch logical errors during the reasoning process and self-correct; second, you can see the reasoning, so if the answer is wrong, you can identify which step failed — rather than facing a black-box answer with an unknown error location.
02 · Why does it exist?
CoT's effectiveness comes from how LLMs generate tokens. Claude produces output one token at a time, with each new token generated based on all preceding tokens. This mechanism has an important implication: the intermediate steps Claude outputs during its reasoning themselves become "context" for subsequent reasoning, providing richer information for each next step.
A simpler analogy: solving a complex math problem entirely in your head (analogous to direct output) forces you to rely on working memory, where errors accumulate. Writing each step down (analogous to CoT) lets you continue by reading your own written steps — each step has the written result of the previous step to build on, naturally improving accuracy. CoT gives Claude the opportunity to "write down and look at intermediate steps," effectively expanding its usable "working memory."
This also explains why CoT is especially effective for complex problems and less impactful for simple ones — simple questions don't require multi-step reasoning; CoT only adds unnecessary output length.
03 · How does it affect your decisions?
Understanding CoT has direct impact on your daily Claude use: you'll know when to add it, what it does when you do, and why some questions still produce poor results even with CoT.
The most direct impact is accuracy. Without CoT, Claude's error rate on complex multi-step problems is significant — it frequently skips steps or makes incorrect assumptions mid-calculation, while still outputting a confident-sounding answer. With CoT, most of these problems are self-corrected during the reasoning process, or at minimum become visible to you so you can catch the error.
For developers, the impact is larger: when building AI applications requiring complex reasoning, integrating CoT into the System Prompt is one of the lowest-cost ways to improve output quality. Many production AI applications enable CoT by default for reasoning steps and disable it for non-reasoning steps (formatting output, simple classification) to manage token costs.
04 · What should you do?
**Immediately usable CoT prompt formats:**
Simplest (Zero-Shot CoT):
```
[Your question] Think step by step.
```
or
```
Please analyze this problem step by step, then give your conclusion.
```
More structured:
```
Please answer using this format:
1. Identify the key conditions of the problem
2. List the solution steps (one step per line)
3. State the final answer
4. Verify whether the answer makes sense
```
With verification (for high-accuracy requirements):
```
Please solve step by step, then verify your answer using a different method.
```
**When to use CoT:**
✅ Math calculations (especially multi-step)
✅ Logic puzzles (if A then B...)
✅ Code debugging (why does this code produce an error?)
✅ Complex analysis (analyze the argument structure of this essay)
✅ Decision evaluation (evaluate the pros and cons of this plan)
**When CoT is unnecessary:**
✗ Simple factual queries (what is the capital of France?)
✗ Simple translation
✗ Creative writing (no "correct answer" needed)
✗ Format conversion (convert this JSON to CSV)
Real-World Example+
Alex is a financial analyst who needs to verify a complex discount calculation. He tried two approaches:
**Approach 1 (direct question)**:
"A product originally costs $1,200. It gets a 20% discount, then an additional member discount of 5%, then 5% tax is added. What is the final price?"
Claude answers directly: "$912.60"
Alex isn't sure this is correct but can't tell where the error might be.
**Approach 2 (with CoT)**:
Same question, adding "Please calculate step by step, showing the formula at each step."
Claude's response:
"Step 1: Original price = $1,200
Step 2: 20% discount → $1,200 × 0.80 = $960
Step 3: Additional 5% member discount → $960 × 0.95 = $912
Step 4: Add 5% tax → $912 × 1.05 = $957.60
Final amount: $957.60"
Seeing the steps, Alex realizes the $912.60 from Approach 1 was wrong (it appears to have either omitted the tax or miscalculated). Each step in Approach 2 is verifiable, and he confirms $957.60 is correct.
This example shows CoT's most important value: not just making answers more accurate, but making the reasoning process transparent and verifiable. For finance, law, and medical use cases where high accuracy is essential, that transparency is itself a core requirement.
Diagram
Feel free to share. Please credit the source.
Common Misconceptions+
✕ Misconception 1
× Misconception 1: CoT makes Claude think more deeply, so every question should use it. CoT's function is making reasoning steps visible — not making Claude smarter or more knowledgeable. For a question that doesn't require multi-step reasoning ("What is the capital of France?"), adding CoT only makes Claude say more unnecessary content ("Step 1: Recall French geography... Step 2: The answer is Paris") — wasting tokens with no quality improvement. CoT applies when the problem itself has multiple reasoning steps with logical dependencies between them.
✕ Misconception 2
× Misconception 2: Once CoT is added, Claude's answer is definitely correct. CoT dramatically reduces error rates in complex reasoning but cannot guarantee 100% correctness. If Claude makes a wrong assumption in the first step, subsequent steps built on that wrong foundation may produce an entirely wrong reasoning chain. CoT's real value: making the reasoning process visible so you can find and correct errors — not guaranteeing a correct answer. Tasks with high accuracy requirements still need human verification of key steps even after CoT.
The Missing Link+
Direct Impact
CoT is a technique with almost no downsides — but its benefits are unevenly distributed, and maximum value requires using it in the right contexts.
**Advantages**: significant accuracy improvement on complex reasoning, especially math and logic; transparent reasoning that enables error detection and correction; Zero-Shot CoT has minimal cost — just one added phrase; stacks well with other techniques (Few-Shot, Role Prompting).
**Costs**: increases output length (higher token consumption) — cost-sensitive API applications need to evaluate this trade-off; no benefit for simple questions, only adds unnecessary output; Claude's "steps" sometimes remain superficial (restating the question counts as a step) — requiring more explicit instructions for "actual calculation steps" rather than just text descriptions.
**Best use cases**: problems with a clearly correct answer; problems whose solution can be decomposed into ordered steps; tasks where any single step error affects the final result.
Generate Share Card
Claude MeGlossary
新手
Chain of Thought (CoT)
思維鏈
"Think step by step" is the simplest CoT trigger phrase
Why it works: forces AI to decompose problems into verifiable sub-steps
Best for: math, logical reasoning, multi-step analysis, code debugging
Not for: simple factual queries — unnecessary overhead, wastes tokens
Zero-Shot CoT vs Few-Shot CoT: the former adds one phrase, the latter provides examples
The Missing Link
Chain of Thought doesn't fix Claude being wrong — it fixes Claude answering too fast. Force it to think first, and accuracy improves dramatically.