Anthropic’s Claude AI model introduced a groundbreaking “extended thinking mode” that lets it adjust how much mental effort it spends on a question. Just like a person can either give a quick answer or take time to work through a tough problem step-by-step, Claude can now operate in two modes: a fast, nearly-instant response mode or a slower, more deliberative thinking mode for complex tasks. Crucially, this isn’t a separate model or a new “reasoning engine” bolted on – it’s the same Claude model being allowed to think longer and harder on demand.
In extended thinking mode, Claude literally generates a hidden chain-of-thought (a “scratchpad”) internally, then uses that reasoning to produce a final answer. Developers and advanced users can toggle this mode on or off and even set a “thinking budget” to control how many tokens (pieces of text) Claude can spend reasoning before it must answer.
Why does this matter? Because complex problems – be it a tricky math puzzle, a nuanced coding bug, or an in-depth analysis – often require multiple reasoning steps, intermediate calculations, and consideration of alternatives. By giving Claude the ability to deliberate internally, it significantly boosts its problem-solving abilities. In fact, Anthropic reports that extended thinking mode gives Claude “an impressive boost in intelligence,” enabling notably better performance on challenging tasks.
This article provides a deep dive into how Claude’s thinking mode works under the hood, what you can expect from it in practice, and how to harness it effectively through prompt design and best practices. We’ll explore Claude’s visible thought process, the architecture of its extended reasoning, and practical examples of prompts that trigger Claude’s most advanced reasoning capabilities.
(Note: While this is a technical discussion aimed at AI developers, prompt engineers, and advanced Claude users, we’ll keep it accessible – assuming you know the basics of large language models but want to build a more detailed mental model of Claude’s “mind” when it’s thinking.)
Extended Thinking Mode Explained
In essence, extended thinking mode allows Claude AI to engage in a multi-step reasoning process before finalizing its answer. Instead of rushing to complete a user’s query in one go, Claude can allocate a portion of its output tokens as “thinking tokens.” During this thinking phase, Claude generates a series of internal thoughts (in natural language form) that it uses to reason through the problem. Only after this internal chain-of-thought is done (or the budget is exhausted) does Claude produce the final answer.
Anthropic’s documentation describes it succinctly: in thinking mode, “Claude produces a series of tokens which it can use to reason about a problem at length before giving its final answer”. This capability was instilled via specialized training (reportedly using reinforcement learning on feedback) so that Claude learned when and how to “think out loud” internally. It’s a hybrid reasoning architecture, meaning Claude can fluidly interpolate between normal single-pass responses and these extended multi-step reasoning passes within the same model. Users have fine-grained control over this: you can leave thinking mode off for quick, straightforward questions or enable it (and even specify how long to think) when you need deeper analysis.
Importantly, this is not a separate reasoning module or a different AI — it’s the very same Claude model simply being allowed to use more computation (more inference steps) on a task. In practical terms, when you enable extended thinking, the Claude API will return two types of content blocks in its response: a thinking block containing the model’s step-by-step reasoning, and then a text block containing the final answer. Behind the scenes, Claude is following a special format where it first produces a hidden scratchpad of thoughts (the thinking content), possibly with multiple steps or sub-answers, and then concludes with the outward-facing answer. The model was designed to incorporate insights from its own thinking chain into the final answer – effectively, it’s consulting its working notes before giving you the result.
To illustrate, suppose you ask Claude: “What is 27 * 453?” Normally, a single-pass model might directly output the answer (and potentially make a mistake if it can’t do it mentally in one shot). In thinking mode, Claude will internally do something like:
- Thought 1: “Let me solve this step by step… First break down 27 * 453.”
- Thought 2: “453 = 400 + 50 + 3, so I can multiply 27 by each part…”
- Thought 3: “27 * 400 = 10,800; 27 * 50 = 1,350; 27 * 3 = 81…”
- Thought 4: “Now sum them: 10,800 + 1,350 + 81 = 12,231.”
It then outputs the final answer: “27 * 453 = 12,231.” In practice, Claude’s internal trace might look like a numbered list of steps similar to the above, which you can actually retrieve via the API. Indeed, an example from the Claude API shows the model streaming its reasoning as a scratchpad and then the answer: first a thinking_delta like “Let me solve this step by step: 1. First break down 27 * 453… 2. 453 = 400 + 50 + 3…” and so on, and finally a text_delta with “27 * 453 = 12,231”. Claude used its allotted thinking tokens to work through the math reliably, then gave the correct result.
How does Claude know when to use extended thinking? Currently, the user or developer explicitly toggles it on. For example, via the API you include a parameter like "thinking": {"type": "enabled", "budget_tokens": 4000} to turn it on and set a token budget. In some interface implementations (like certain coding assistants or chat UIs built on Claude), there may be a “Think harder” button or the option to press Tab to toggle thinking mode. The key is that the user remains in control – you decide when you want Claude to engage its extended reasoning. By design, this mode is intended for “particularly complex tasks that benefit from step-by-step reasoning like math, coding, and analysis,” as the guidelines note. Simpler questions (“What’s the date today?”) don’t need it and indeed Claude can answer those nearly instantly without any visible scratchpad.
That said, Anthropic has hinted at a future where Claude might automatically gauge difficulty and decide how long to think, without the user always having to ask. This would mimic human behavior – we naturally spend more time on harder questions. For now, though, think of extended thinking as a manual turbo-charging switch: flip it on when you need Claude to be thorough, methodical, and patient in reaching an answer.
Under the Hood: Claude’s Extended Reasoning Engine
So, what’s happening internally when Claude “thinks” for an extended period? Although Anthropic hasn’t open-sourced Claude’s architecture, they’ve shared insights into the mechanism:
- Serial Reasoning Steps: In thinking mode, Claude engages in serial test-time compute. This means it performs multiple sequential reasoning steps (token generation steps for its chain-of-thought) before finalizing output. Essentially, it’s allocating more compute cycles and attention to the query, iteratively refining its understanding. Empirical results show this yields measurable gains: for example, Claude’s accuracy on math questions increases logarithmically as the number of thinking tokens allowed increases. In one benchmark (the 2024 AIME math exam), giving Claude a larger “thinking budget” led to higher scores – more reasoning steps = better accuracy, up to a point of diminishing returns.
A graph from Anthropic’s research showing Claude 3.7’s math problem accuracy improving as more “thinking” tokens are allowed. The x-axis is the number of tokens used in Claude’s internal chain-of-thought, and the y-axis is accuracy on a set of math questions. We see a clear upward trend: allowing a few thousand thinking tokens yields moderate accuracy, which continues rising as the budget increases (though gains level off beyond a certain token count). This demonstrates how extended reasoning boosts performance on complex tasks by letting Claude devote more computation to them.
Internal Scratchpad (Visible Chain-of-Thought): Claude’s intermediate reasoning takes the form of a textual scratchpad that can be made visible. Unlike the final answer, this scratchpad isn’t polished prose or a role-playing persona – it’s raw, analytical thinking content. Anthropic deliberately did not apply the usual “character” style tuning to the thinking process, to give Claude free rein to think in whatever way helps it solve the problem. Consequently, if you view the raw thought process, you’ll notice it’s more detached and impersonal than Claude’s normal answers, and it may include partially incorrect or speculative thoughts that Claude later corrects. This is normal – much like a human brainstorming or working through a calculation might jot down some false starts before arriving at the correct solution.
Incorporation into Final Answer: Claude treats the reasoning it generates as a guide to formulate the final answer. The model “looks at” or conditions on its own thinking steps when producing the answer block. In other words, the chain-of-thought is not just for the user’s benefit; it genuinely influences Claude’s output. For example, if during the thinking phase Claude deduces intermediate results or sub-conclusions, the final answer will be based on those deductions. This helps with complex multi-part questions, because Claude isn’t trying to hold all the logic in its head at once – it has an explicit trail of breadcrumbs to follow.
Architectural Support: To enable this, there are likely under-the-hood prompt or architecture adjustments. The Claude API documentation notes that when thinking mode is on, a special system prompt is automatically included to instruct the model to produce the thinking blocks and then answer. The model’s training via RL fine-tuning would have included many examples of doing reasoning steps internally (often called chain-of-thought training). There’s even an indication that Claude 3.7 uses multi-headed attention and gating mechanisms to decide when to invoke extended thinking – suggesting an internal “mode selector” that can dynamically allocate more compute to hard tasks. (This detail, while not officially confirmed, aligns with the description of a hybrid reasoning architecture that “automatically determines when to engage its extended thinking process” based on task difficulty.) In simpler terms, Claude has learned a sort of meta-skill: deciding how much reasoning effort a query warrants, and then carrying out that level of effort.
Thinking Budget: The “thinking budget” is a user-defined cap on how many tokens Claude can spend in the thinking phase. This is crucial for practical use, because it gives developers control over the trade-off between depth of reasoning and latency/cost. A higher budget lets Claude explore more possibilities or follow longer inference chains (which can improve quality on very hard problems), but it will take longer and consume more tokens (which might incur higher API costs). Anthropic sets a minimum budget of 1,024 tokens, and you can increase from there in increments, observing how quality improves. They recommend starting small and scaling up – often, a few thousand tokens of thinking is enough to get significant gains, and beyond a certain point you hit diminishing returns. In fact, the model often doesn’t even use the full budget if it finds an answer sooner (it can stop early when it’s confident or done reasoning). Example: If you set a 4,000 token thinking budget, Claude might only use, say, 2,000 of those tokens to reason and then produce an answer if that was sufficient. But if you set only 500 tokens, it may cut off its reasoning prematurely and give a less-developed answer. Finding the optimal budget can depend on the task – e.g. a simple coding error might need <2k tokens of reasoning, whereas analyzing a lengthy legal document could profit from 8k+ tokens of thought. Experimentation is encouraged: Anthropic notes that different tasks see benefits at different budget levels, so tuning this parameter helps balance quality vs. speed.
Cost and Token Counting: When using extended thinking, remember that those “invisible” thinking tokens still count as output tokens for billing. You’ll be charged for the full internal reasoning that Claude generates, even if you only see a summary of it. In Claude 4 models, Anthropic by default provides a summarized thinking output (more on that shortly) so you don’t see all 10k tokens it may have churned through, but you’re billed for them. This is important for developers to consider when enabling long budgets. Also note that enabling thinking mode disables certain other settings: for instance, you cannot modify the model’s randomness (temperature, top_p, etc.) when thinking is on. Claude’s reasoning mode runs in a deterministic, focused manner – this likely helps ensure the chain-of-thought is logical and repeatable, instead of wandering due to randomness. You also cannot use “partial output” features like pre-filled answers or certain forced behaviors with thinking enabled, because the model needs full freedom to decide the course of its reasoning.
Not a Perfect Window into the Mind: One might think that seeing Claude’s chain-of-thought is like reading its mind, but Anthropic cautions that “we don’t know for certain that what’s in the thought process truly represents what’s going on in the model’s mind.” In AI research this is called the faithfulness problem. The model could be using some latent knowledge or heuristic without explicitly writing it down in the scratchpad. In fact, studies found that “models very often make decisions based on factors they don’t explicitly discuss in their thinking process.” In plainer terms, Claude’s visible thoughts are a helpful narrative and typically aligned with how it reached the answer, but they might not tell the whole story. The chain-of-thought can omit or even intentionally conceal certain reasoning if the model “knows” those thoughts would be unhelpful or disallowed to show. For example, if part of solving the problem involves sensitive content or a policy violation, the model might internally consider it but not echo it in the visible chain-of-thought. Bottom line: the thinking mode is a great transparency tool, but it’s not an infallible, complete log of every computation. We can’t 100% trust it as a definitive explanation of why Claude answered the way it did. It’s more like a helpful reasoning narrative.
Safety and Redactions: Because the thought process could sometimes stray into problematic content (e.g. contemplating a forbidden request, testing a possibly biased assumption, etc.), Anthropic built in safeguards. In rare cases where “Claude’s thought process might include content that is potentially harmful,” Claude will encrypt or redact those portions in the visible log. The user might see a message like “the rest of the thought process is not available for this response” instead of the actual text. This ensures that even though Claude might think about something hazardous as an intermediate step, it doesn’t expose that to the user (while still allowing the model to utilize that thinking to produce a safe final answer). Additionally, Anthropic has streaming classifiers watching the output to prevent private data or unsafe content from leaking via the scratchpad. So far, these cases are rare – most of the time the visible chain-of-thought is benign – but it’s an important consideration if you plan to show end-users the model’s reasoning.
Summarized vs. Full Thoughts: One difference to note between Claude 3.7 (the version that debuted extended thinking) and Claude 4 (newer models) is how the thought output is handled. Claude 3.7 would return the full raw chain-of-thought to the user/developer by default. Claude 4 models, however, by default return a summarized version of the thinking content. Anthropic made this choice to prevent misuse (since raw thoughts could be very long or occasionally contain sensitive bits) and to improve latency. The summary condenses the key reasoning points so you still get transparency and the “full intelligence benefits,” but without dumping tens of thousands of tokens of raw text at you. For example, if Claude internally used 20k tokens reasoning, it might summarize that down to a few hundred tokens highlighting the main line of thought. They mention that “the first few lines of thinking output are more verbose, providing detailed reasoning that’s particularly helpful for prompt engineering purposes” – in other words, the summary will still give you a good sense of how Claude approached the problem, especially at the beginning, which can help you refine your prompts or debug issues. Enterprise/API users who truly need the full raw chain-of-thought can request access to it (Anthropic notes you can contact them to get the full thinking output on Claude 4), but for most use cases the summary is plenty. As an end-user of, say, Claude’s chat interface, you’ll likely only see either the summary or perhaps no explicit thoughts at all (some consumer UIs might hide the chain-of-thought entirely and just use it behind scenes to improve answers).
In summary, Claude’s extended reasoning engine works by giving the model extra time and space to solve hard problems. It creates a step-by-step plan/analysis internally, uses that to get the answer, and optionally reveals that plan to the user. This approach yields more reliable and nuanced results on complex tasks, at the cost of extra tokens and time. It’s a major step toward AI systems that can scale their “cognitive effort” dynamically, rather than treating every query with the same shallow approach. In the next sections, we’ll look at how this actually plays out in practice – what kinds of improvements you’ll observe, how to invoke thinking mode effectively, and examples of Claude tackling tough problems with and without extended thinking.
What You’ll Observe in “Thinking” Mode
Using Claude’s thinking mode can be an eye-opening experience. Here are the key differences and behaviors you’ll notice when extended reasoning is enabled:
- Step-by-Step Answers: The most obvious change is that Claude’s answers become much more structured and stepwise when it has had a chance to think. Rather than jumping straight to a conclusion, Claude will often present a reasoned solution path. For instance, on a complex logic puzzle, instead of a one-paragraph answer, you might get a multi-paragraph explanation: first clarifying the puzzle, then examining possible interpretations, ruling out options, and finally stating the answer with justification. The final output is more like reading an expert’s working notes concluding with the solution. This is because Claude effectively did write those working notes internally – and even if the raw scratchpad isn’t shown verbatim, the influence is clear in the answer’s coherence. Users have reported that Claude’s answers in thinking mode are more thorough and better justified, because it had time to double-check itself and fill gaps in reasoning. In technical domains (like coding or math), you’ll see formulas, pseudo-code, or sub-calculations laid out methodically, which indicates Claude was following a logical sequence of steps rather than guessing.
- Slower, Deliberate Responses: Naturally, engaging in extended reasoning makes Claude’s responses slower. You’ll notice a longer pause or a streaming output that takes more time to complete. For example, a query that Claude might answer in 5 seconds normally could take, say, 30 seconds or more if you give it a large thinking budget. This is expected – it’s literally doing more computation. If you’re watching via streaming, you might actually see the thinking content arrive first (if you’re privy to it) followed by the final answer. The streaming might come in chunks: Anthropic notes that thinking content tends to stream in “larger chunks alternating with smaller, token-by-token delivery,” due to how the system batches the reasoning steps. So don’t be surprised if the text appears a bit unevenly; the model might generate a bunch of reasoning text internally and then send it out in one go. The final answer text usually streams token-by-token after the thinking is done.
- Visible “Scratchpad” (Optional): If you have access to the thought process (for example, in the Claude Console or via API with
thinkingcontent enabled), you’ll literally see a markdown-styled scratchpad appear above the final answer. It often starts with phrases like “Let me think this through:” or “Step 1: …” because the model has been instructed to be explicit in its reasoning. It may enumerate steps or bullet points, draw intermediate conclusions, and even sometimes ask itself rhetorical questions. This raw thinking output can be fascinating – as Anthropic researchers observed, “some noted how eerily similar Claude’s thought process is to their own way of reasoning through difficult problems”. For example, when debugging code, Claude’s scratchpad might show it tracing through functions, checking edge cases, and considering multiple strategies before it chooses one. As a user, being able to peek into this process can build trust: you can follow along and verify the logic or catch where it might be going wrong. In fields like education or analyst work, showing the reasoning can also be directly beneficial (students can learn from the step-by-step approach, or an analyst can audit the AI’s decision path). - Less Polished Tone in Thoughts: One thing to be aware of: the content of the thinking scratchpad may sound more robotic or blunt compared to Claude’s normal friendly style. This is intentional – Claude’s chain-of-thought isn’t run through the same formatting and style guidelines as its final answers. It might refer to “the assistant” or use very dry language. It might also contain tentative or incorrect statements that Claude corrects by the end. For instance, mid-way the chain might say “(Hmm that approach doesn’t work, let me try another angle)” if it realizes a mistake. This doesn’t mean Claude is broken; it means it’s working on the problem. If you only saw the final answer, you’d never know about those false starts – but with thinking mode visible, you do. Some users find this transparency reassuring and useful for troubleshooting prompts. Others might find it cluttered or “less magical” to see behind the curtain. It’s your choice whether to expose it – you might use it during development and then hide it from end-users in a production app (or provide it as an optional “Explain how you got this answer” feature).
- Higher Accuracy on Complex Tasks: The ultimate benefit of thinking mode is improved performance on tasks that require reasoning. You can expect Claude to solve problems that previously stumped it or produce more accurate, consistent outputs on things like multi-step math, long-form synthesis, and code generation. For example, Anthropic reported huge gains on coding benchmarks when using extended thinking. Claude 3.7’s score on a software engineering benchmark (SWE-Bench) jumped from around ~49% to over 62% with the introduction of extended thinking, outperforming other models, thanks largely to the chain-of-thought capability. In an agent simulation benchmark (TAU-Bench, involving interactive decision-making), extended thinking similarly boosted Claude’s success rate (81.2% vs ~73.5% for others). These improvements come from Claude being able to simulate multiple solution pathways and reflect before answering. For instance, in coding, it might mentally draft and evaluate several possible fixes for a bug and only output the best one – a process that, without thinking mode, it cannot do in a single pass. The result is fewer errors and more robust solutions. Users have anecdotally observed that Claude with thinking enabled makes far fewer “unnecessary refusals” (false negatives on allowed requests) and also fewer mistakes on tricky logical queries. This aligns with Anthropic’s data that showed a 45% reduction in unnecessary refusals and generally more accurate judgment calls – essentially, giving the model a moment to think helps it avoid both factual mistakes and misapplications of safety filters.
- Agentic Behavior with Tools: Another striking effect is when Claude is used in an agent setup with tools (via the Claude API’s tools system or in a coding assistant environment). Extended thinking allows interleaving tool use with thought – meaning Claude can think, decide to call a tool (like a calculator, web search, code execution tool, etc.), get the result, then continue thinking based on that result. This is akin to how a human would solve a problem using tools: plan a step, use a resource, see what happened, adjust the plan, and so on. Claude with thinking mode can do exactly that in one continuous flow. For example, if asked a question that requires looking up information, Claude might have a thought like “I should use the web search tool for this part” in its scratchpad. It then outputs a
[tool_use]action to perform the search (the platform handles the actual search call and returns the result), which Claude receives, and then its thinking scratchpad will show it analyzing the search result before composing a final answer. This agent loop powered by extended reasoning is very powerful – it effectively lets Claude handle multi-step operations autonomously. Anthropic demonstrated this in a controlled way with Claude 3.7, where it used extended thinking plus an “action loop” to control a virtual computer and even play a full game of Pokémon Red! Previous Claude versions without extended thinking would get stuck quickly in such tasks, but Claude 3.7 was able to plan strategies, try different approaches when stuck, and carry on for tens of thousands of actions to achieve goals (defeating multiple game bosses in that example). This showcases how the combination of long-horizon thinking and tool use enables a form of agency — Claude can sustain context and pursue an objective over a long sequence of steps, far beyond its raw context window. For everyday users, this means tasks like “read these files and assemble a report” or “diagnose this server issue using logs and propose fixes” become much more feasible for Claude to do autonomously, given it can loop through steps methodically. Integration details: If you’re a developer enabling tools with extended thinking, note that you must allow Claude to choose tools freely (you can’t force a specific tool in a thinking loop), and you need to pass thethinkingcontent back with each tool result so Claude remembers its prior thoughts. The system ensures these thinking tokens don’t bloat the context or get counted twice – they are filtered out when sending to the model’s next step, used only to maintain continuity. Done right, Claude can intermix[thinking]and[tool_use]blocks fluidly to solve problems that involve external actions or long workflows. (Imagine a customer support bot that can brainstorm a solution, run a database query via a tool, then continue reasoning based on the query results – that’s the kind of capability extended thinking unlocks.) - When Not to Use It: It’s worth noting that thinking mode isn’t always beneficial. For very simple queries or rote knowledge questions, extended reasoning is overkill – it will slow things down with no added value. In worst cases, it could even introduce confusion: if forced to think step-by-step about a very straightforward fact, the model might start over-complicating it. Anthropic explicitly advises using extended thinking selectively for complex tasks. The good news is Claude is built to operate in a hybrid way; you can call it with thinking off by default, and only trigger it for certain turns or certain user queries that meet complexity criteria. Some developers even implement logic like: if the user’s question is short or looks trivial, call Claude normally; if it’s long-form, ambiguous, or multi-part, call Claude with extended thinking. This way you optimize latency and cost. Also, if you ever find that Claude in thinking mode is producing a lot of unnecessary steps or going in circles, you might try reducing the budget or turning it off. Usually, though, the model is pretty good at not “overthinking” beyond the point of usefulness – it won’t just pad out the chain-of-thought for no reason, given it wasn’t trained to waste tokens.
In summary, Claude’s thinking mode tends to produce answers that are more trustworthy, detailed, and logical, at the expense of being a bit slower and more verbose. For anyone pushing Claude to its limits – be it in debugging a gnarly codebase, analyzing lengthy reports, or tackling open-ended reasoning problems – this mode is a game-changer. Next, let’s delve into how to get Claude to use this mode effectively, including prompt strategies and examples of extended reasoning in action.
Prompt Engineering for Extended Reasoning
Claude’s extended thinking can be activated without fancy prompt tricks (just toggle the mode), but how you prompt the model still matters enormously in guiding its reasoning. When aiming to get the most out of Claude’s “thinking” mode, consider the following prompt engineering techniques:
1. Directly Request Step-by-Step Reasoning
Even with thinking mode off, it’s a known best practice to ask models to “think step by step” for complex problems. With Claude, you can explicitly include instructions in the prompt such as: “Please show your reasoning step by step before giving the final answer.” This tends to trigger a manual chain-of-thought in the output itself. When extended thinking mode is on, Claude is already internally doing this, but it can still help to align the final answer with a logical structure. Essentially, you’re telling Claude that you value the reasoning process, so it should reflect that in its answer.
Example (Analytical Reasoning):
User Prompt A: “What are the pros and cons of implementing microservices in our web application architecture?”
Claude’s answer without guidance: Might be a decently structured paragraph or two, but could be somewhat generic or miss depth.
User Prompt B (with step request): “As an experienced software architect, list out the pros and cons of implementing a microservices architecture for our web app. First, outline your thought process (assumptions, factors considered) step by step, then provide the final recommendation.”
Claude’s answer with thinking mode on: Claude will likely produce a clearly divided answer. It might start with an outline of considerations (e.g. “1. Scalability – microservices allow independent scaling of components… 2. Complexity – however, managing many services introduces complexity… 3. Team Autonomy – teams can own services… etc.”), perhaps as an internal scratchpad or even directly in the answer. It will then conclude with a recommendation that directly ties back to these points. By explicitly asking for a step-by-step outline, we encourage Claude to not skip any important angle it thought about.
This approach is particularly useful for multi-factor analysis (trade-off discussions, pros/cons, SWOT analyses, etc.). Claude’s internal chain-of-thought will naturally enumerate factors, and by prompting this way we get a thorough answer. It also reduces the chance of Claude forgetting to mention something it did consider internally.
2. Use Role-play to Set a Reasoning Context
Claude responds well to “role prompts” that frame how it should approach a problem. For complex reasoning, you can ask Claude to act as a certain type of expert or to adopt a certain cautious mindset. This doesn’t directly toggle thinking mode, but it influences the style and depth of the reasoning.
Example (Role-based reasoning):
Prompt: “You are a senior data scientist tasked with analyzing a new dataset. Before jumping to conclusions, carefully think through how you would approach the analysis: consider what questions to ask, what models to try, and how to validate results. Walk through this planning process step by step, and then give your final recommended analysis plan.”
Here, we’ve set Claude up as “a senior data scientist” and explicitly asked it to walk through the planning process. In thinking mode, Claude will likely generate an internal plan (maybe listing data cleaning, exploratory analysis, feature engineering, modeling, validation steps, etc.), and because of the prompt, it will also articulate that plan in the answer. This method leverages Claude’s strength in following personas or high-level instructions. By adopting the persona of an expert who naturally thinks methodically, Claude’s chain-of-thought is guided to be more rigorous and its final answer will mirror that rigor.
Role prompts can be tailored to the domain: e.g., “Act as a meticulous accountant and double-check every calculation…” or “Behave like a wise legal advisor, considering each precedent step-by-step…”. These encourage Claude to emulate the deliberative thinking style of those roles. Combined with extended thinking mode, the results are very robust explanations.
3. Prompt Decomposition (Chaining Prompts Manually)
Another strategy is to break a complicated query into sub-questions explicitly in your prompt. Essentially, you hand-hold the chain-of-thought by asking intermediate questions. With standard LLMs this is known as chain-of-thought prompting or decomposition prompting. With Claude, you can do it within one prompt by instructing it to go in stages.
Example (Complex problem solving):
Suppose you have a complex puzzle or a multi-step math word problem. You can prompt:
“Let’s break this down: First, restate the problem in your own words and identify what is being asked. Next, list out any important details or constraints. Then, work through the calculations or logical steps needed, one by one. Finally, give the answer at the end.”
What this does is provide a framework for Claude’s reasoning. In extended thinking mode, Claude will fill in each part in its scratchpad, aligning with your requested structure. By the time it answers, you get a nicely organized solution trace. This is extremely useful for things like multi-step math (unit conversion problems, geometry proofs, etc.), where a single misstep can lead to a wrong answer. By decomposing the prompt, you catch those steps. In fact, you can combine this with verification: ask Claude after giving an answer to “Now double-check each step for errors.” With thinking mode on, it can internally verify and correct its own working. This hints at a powerful use: self-reflection prompts, where you explicitly tell Claude to reflect on whether its answer seems correct or if there are alternative interpretations. For example: “Provide your answer, then reflect in a few sentences on how confident you are and if anything could be wrong.” Claude might produce an answer and then an internal post-answer thought like “I should double-check edge case X,” leading to a corrected answer if needed.
4. Leverage Multi-Shot Prompting with Reasoning Examples
One advanced technique, especially in the API or custom setups, is to show Claude examples of good reasoning in the prompt. For instance, you can provide a few Q&A pairs where the assistant walks through a solution step-by-step (these could be simple illustrations of the format you want). This few-shot prompting can prime Claude to follow a similar chain for your actual question. Anthropic’s own prompt engineering guide suggests that giving examples can greatly help model performance. In context of extended thinking: if you provide a demonstration of a model “thinking out loud” and solving a sample problem, Claude will mimic that approach for the new problem, often to great effect.
Example (few-shot chain-of-thought):
You might include in the system or few-shot prompt something like:
- Example User: “How many prime numbers are there between 50 and 100?”
- Example Claude: “Let’s think this through. First, list primes between 50 and 100… (then it lists them and counts)… There are 10 prime numbers in that range.”
By giving this example, when the real user asks a hard question, Claude already has a pattern: think step-by-step, enumerate as needed, then answer. This can be useful if you find Claude’s first attempt is too terse or skips reasoning. Essentially you’re positively reinforcing the behavior of showing the work. When extended thinking mode is on, Claude always generates the chain-of-thought internally, but with a good few-shot prompt, you also get a well-formatted reasoning in the output if you want to show it.
One caution: including large examples will eat into your context token budget. But since Claude has an ample context (in Claude 4, up to 100K tokens), a couple of examples is usually fine. Additionally, multi-shot prompting might not be necessary if you trust Claude’s own reasoning style; often a single “Think step by step” instruction suffices thanks to Claude’s training.
5. Long-Context Strategy – Guiding Navigation of Big Inputs
Claude is known for having a huge context window (tens of thousands of tokens). Thinking mode makes it more capable of utilizing that context wisely. However, if you dump a very long document or multiple documents into the prompt and ask a broad question, it helps to guide Claude’s approach to the long text. For example:
Instead of: “Here is a 50-page report on climate data. Summarize the main findings.” (Claude might do okay, but it’s a lot to process even with extended thinking)
Try: “You have a 50-page climate data report. Step 1: Skim the document and identify the major sections or themes. List those first. Step 2: For each major section, write a brief summary of the key points. Step 3: Conclude with an overall summary of the main findings across the report.”
This prompt essentially instructs Claude how to chunk the task. In thinking mode, it will likely follow this plan: internally noting the sections, summarizing each internally, and then compiling the final answer. By chunking, you ensure Claude doesn’t get lost in the details or skip a section due to token limits. Extended reasoning is particularly useful here because Claude can maintain a kind of working memory of what it read in earlier parts via the scratchpad. (Claude might internally write notes like “Section 1 is about temperature trends… Section 2 deals with precipitation… etc.” which helps it not forget by the time it gets to the conclusion.)
Anthropic’s documentation suggests not to worry about including previous thinking blocks in the prompt when continuing a conversation – the API will handle context and ignore old thinking blocks automatically. So you can focus your prompt on instructing future reasoning rather than carrying over all past reasoning verbatim. Still, providing references or anchors in a long context helps. For instance: “In the following text, pay special attention to Chapter 3 (methods) and Chapter 5 (conclusion) when formulating your answer.” Such hints guide Claude’s internal focus during extended thinking, which can lead to a more relevant answer.
6. Before/After Example of a Prompt Enhancement
To concretely demonstrate the impact of these prompt strategies combined with thinking mode, let’s walk through a specific scenario:
Task: You want Claude to troubleshoot a piece of code and suggest a fix. The code and error are somewhat complex.
- Prompt without optimization: “Here’s some Python code (provide code). It’s not working – please fix the bug.”
- Claude’s likely behavior (no thinking mode or guidance): It will try to parse the code and quickly guess a fix. It might identify the error if it’s simple, but if the bug requires understanding context or multiple steps (e.g., an algorithm logic issue), it could give a partial fix or hallucinate a change that doesn’t fully solve the issue. The answer might be short: “I think you should change X to Y,” without much explanation. If it’s wrong, you wouldn’t know the reasoning it used.
Now add extended thinking and better prompting:
- Improved Prompt: “You are an expert Python developer. The user provided the code below and it’s not working. Think through the debugging process step by step: first, understand what the code is supposed to do, then identify any errors or problematic areas, and finally suggest a corrected version of the code. Explain your reasoning thoroughly, and then present the fixed code.” (Then provide the code.)
- Claude with thinking mode on, response: You would see Claude systematically analyze the code. For example, its scratchpad may show: “The code is trying to do X. Step 1: Check function definitions… Step 2: Notice that variable
foois not defined before use – likely the bug. Step 3: The logic in the loop might also be off-by-one.” It will then explain in the answer: “The bug is thatfoowas never initialized, which causes an error. Also, the loop runs one too many times. I will fix these by addingfoo = []before the loop and adjusting the loop range.” Then it provides the corrected code. This answer is far more useful: you not only get the fix but understand why. The extended thinking ensured no stone was left unturned; if there were multiple issues, Claude likely caught them because it went line-by-line internally.
As this example shows, combining thoughtful prompt design (“explain step by step, assume expert role”) with Claude’s extended reasoning leads to very high-quality outputs. It’s like having a supercharged collaborator who not only gives you answers but also teaches you and shows their work.
Long-Context Reasoning and Planning with Claude
One of Claude’s standout features is its ability to handle very long contexts (up to 100K tokens in Claude Instant 100k, and similarly large in Claude 2 and beyond). Extended thinking mode pairs especially well with long contexts, because it gives Claude the “mental breathing room” to make sense of large amounts of information or to conduct lengthy reasoning across a big knowledge base. Let’s explore a couple of scenarios:
Long Document Summarization & Analysis
Imagine you provide Claude with a full book or a massive research paper. Summarizing or analyzing such a text is challenging for any model – not just because of length, but because extracting the essence requires reasoning (what’s important? what’s the argument structure? etc.). With extended thinking mode, Claude can effectively skim and distill large texts more intelligently. Its chain-of-thought might involve steps like: “Chapter 1 seems to be about X, Chapter 2 about Y… The main thesis is developing as follows… (makes notes)… these three points stand out.” By the end, the summary it delivers is coherent and captures the major points, often better than a baseline approach that might simply grab sentences without deeper understanding. Additionally, if you ask analytical questions (e.g., “What are the weaknesses of the author’s argument in this report?”), Claude can simulate a critical reading. It could internally map out the argument, then inspect each part for assumptions or flaws, before answering. Users have found that extended thinking helps Claude maintain consistency when summarizing very long texts – since it can remind itself of earlier parts via the scratchpad notes.
A practical tip: if you have multiple documents, you can supply them each labeled, and prompt Claude to analyze relationships. For example: “You have Document A (content…), Document B (content…). First compare their key points individually, then discuss how they relate (agree, conflict, complement). Finally answer: Does B support the conclusions of A?” In thinking mode, Claude will likely take a structured approach: summarize A, summarize B, list comparative notes, then give a conclusion. Without thinking mode, it might try to do this in one shot and potentially mix information or forget something from earlier in the prompt. Extended reasoning acts like an internal notepad, which is invaluable when dealing with a lot of info.
Multi-Step Logical Reasoning & Puzzles
Claude’s chain-of-thought shines on problems that humans might solve by writing things down. Think of math word problems, logical puzzles (like Sudoku or logic grids), or even tasks like writing a proof or deriving a formula. With extended thinking, Claude can carry forward intermediate results. For a math example, if asked “What is the sum of all multiples of 7 between 1 and 1000?”, Claude might: compute how many multiples (floor(1000/7)), find the first and last multiple, apply the arithmetic series sum formula – all internally – then give the answer. If any slip happens, you can see the step where it went wrong (maybe it miscomputed the count by 1) and correct or reprompt. This dramatically improves reliability on tasks where one small mistake can spoil the answer.
For logic puzzles, say a classic riddle with multiple clues, Claude can set up an internal deduction grid. Users have observed Claude writing out assumptions and testing them in the scratchpad when allowed to think. It might say in the chain-of-thought: “Clue 1 means either A or B is the thief. Clue 2 means C cannot be in the same room as A…” etc., eventually deducing the solution. Without extended thinking, it might not keep track of all these interlocking clues effectively and give a wrong or incomplete answer. Essentially, thinking mode allows Claude to simulate human-like problem-solving, where you break a puzzle into sub-problems, solve each, and combine results.
Planning, Project Management, and Workflows
Another domain is high-level planning or procedural tasks. If you ask Claude to, for example, develop a project plan or a multi-step strategy, extended thinking helps it not just spit out a list, but to ensure the list is coherent and covers all necessary steps. For instance, “Give me a detailed plan to launch a new product in 6 months” – Claude might internally outline phases (market research, prototyping, marketing, etc.), then flesh each out with sub-tasks, then compile the final plan. The outcome is often a very well-organized plan with logical progression. If thinking mode is off, Claude may still produce a good plan (these models are decent at structured output), but it might be less detailed or miss a critical step because it didn’t actually reason through dependencies. With the scratchpad, it might note “if marketing starts too late this fails – ensure to include a marketing prep step early” and thus include it in the answer.
Anecdotally, users who have complex workflows (like multi-step data processing or lengthy question answering sessions) have found that enabling thinking periodically can “reset” or clarify the model’s approach. For example, in a multi-turn conversation, you might say: “Let’s pause and let Claude summarize what we have and formulate a plan.” That prompt with thinking can have Claude output a clear plan for the remaining conversation or task. This is hugely helpful in long dialogs or when the user’s goal evolves over time – the model can keep track via its extended thoughts.
Self-Correction and Reflection
One exciting use of extended reasoning is having Claude reflect or double-check itself. You can explicitly prompt it to do so, or it might do it automatically if it’s unsure. For instance, after giving an answer, you can ask, “Claude, please verify the solution step-by-step and confirm if it’s correct.” In thinking mode, Claude will then go through its own answer, re-derive the result, and either confirm or correct it. This is like having a reviewer built in. Claude might catch its own arithmetic mistake or realize an assumption was wrong and then give a revised answer. This approach is aligned with research on improving LLM reliability: having the model generate an answer then evaluate it from scratch tends to improve accuracy. Claude’s extended mode allows this in one call (it can produce an initial solution internally, then a second pass checking it, then final output).
Developers could use this pattern programmatically: e.g., always ask Claude to provide an answer and a brief reasoning check. If the reasoning check finds an inconsistency, you know the answer might be wrong. This could be done behind scenes, only surfacing the final answer to the user. With the visible scratchpad, you as a developer can parse the thinking content to see if Claude expressed doubt or contradictions, and handle accordingly (maybe ask the question in a different way or reduce complexity).
Best Practices and Considerations
To wrap up, let’s summarize some best practices for making the most of Claude’s thinking mode, as well as important considerations:
Use it for the Right Tasks: Not every query needs extended thinking. Save it for problems that involve multiple reasoning steps, ambiguity that needs exploration, or extensive content to navigate. Good candidates: complex math problems, programming assistance, analytical writing, summarizing long documents, planning tasks, “how/why” explanation questions, etc. Poor candidates: very simple factual Q&A, short queries that look like they need a quick fact (turning on thinking for “What is the capital of France?” is unnecessary – it might still get it right, but you’re wasting time).
Tune the Thinking Budget: Start with the minimum (1024 tokens) if you’re unsure, and gradually increase if you see the model’s answers are being cut off or could benefit from more depth. Watch the token usage in the output: if Claude consistently uses, say, ~800 tokens of reasoning and then stops, increasing beyond 1024 won’t help that particular query. On the other hand, if it maxes out the budget and you get a sense it had more to say (or it explicitly says “I ran out of time”), then increase the budget. Keep in mind the total context limit – budget_tokens must be less than max_tokens for the response, and together with your prompt they must fit in the model’s context window. Claude 4 has a huge window (100k), but Claude 3.7 had smaller (perhaps 32k). The system will error if you set a budget that plus prompt exceeds the window. Plan accordingly, especially if giving it extremely long texts and a large thinking budget.
Streaming vs. Non-Streaming: For very large reasoning budgets (like >20k tokens), Anthropic actually requires using streaming. The reason is the model might take minutes to complete and output thousands of tokens; streaming ensures your connection doesn’t time out and you can show partial progress. If you’re building an app, design your UI to handle two types of content blocks: the thinking and the final answer. You may choose to hide the thinking from end-users, but you still need to read it from the stream and discard it (or log it). Some developers present a “Claude is thinking…” loader with maybe a few teaser lines of reasoning for transparency, then reveal the answer. Decide what’s best for your use case.
Don’t Mix with Certain Features: As mentioned, avoid using temperature, top_p, or forced tool selection with thinking mode. Also, you cannot use the “pre-fill” feature (where you supply a partial answer for Claude to continue) when thinking is on. These restrictions exist because extended thinking expects full autonomy to figure out the solution. If you try to combine them, the API will likely throw an error or just ignore the conflicting parameter. If you need a creative, varied brainstorming (which would normally use higher temperature), consider running Claude in normal mode with temp on, or do two calls (one in thinking mode for a solid answer, another in creative mode for alternatives).
Monitor Cost and Latency: Thinking mode can generate a lot of tokens, especially if you use a large budget. Recall that you pay for all those tokens. If you set a 10,000 token budget and Claude uses it fully every time, that’s a hefty output count (plus the final answer tokens) – potentially expensive if doing many queries. Use logs to see average token usage and adjust budgets as needed to minimize over-allocation. Similarly, user experience can suffer if responses take too long. If you notice certain prompt patterns lead to huge, slow chains-of-thought that maybe aren’t necessary, refine your prompt or reduce the budget. For instance, overly open-ended instructions like “think of absolutely every possible approach” could make Claude exhaust the budget. Instead, maybe instruct “consider the most likely approaches” to keep it efficient. The key is balancing thoroughness with pragmatism.
Handle the Scratchpad Safely: If you do display the chain-of-thought to end-users (or even use it internally for debugging), remember it might contain mistakes or content that wouldn’t normally pass moderation. While Claude is trained not to produce disallowed content even in thoughts, the Anthropic research showed it can sometimes contemplate something it wouldn’t say out loud. Use the provided encrypted/redacted indications as signals – if the scratchpad is partially withheld, definitely do not try to force it or reveal it (there’s a good reason). Also, you may want to clarify to users what the thinking content is if you show it. Explain that it’s an AI’s intermediate reasoning, which could include wrong turns or rough notes. This sets the right expectations and turns it into a learning opportunity rather than confusion. If you prefer not to show it at all, you can rely on the summarized thinking or simply discard the thinking blocks on output – the final answer is what matters for most applications. Some apps choose to log the reasoning for developers (to aid prompt tuning or audit trails) but not show it to the user.
Prompt Caching Implications: If you’re using Anthropic’s prompt caching (which saves embeddings of prompts for faster responses), be aware that switching thinking mode on/off will change the prompt format, thus cache keys. Also, if you change the budget size frequently, those become cache misses because the system prompt differs. In practice, this is a minor consideration: you might keep thinking mode consistently on or off for certain conversations rather than toggling every turn. If you do need to toggle (maybe one specific user query needs thinking in an otherwise normal convo), it’s fine – just note that that turn won’t benefit from any cached prefix. Extended thinking tasks often exceed 5 minutes, so Anthropic suggests using their longer cache TTL (1 hour) if you want caching to work on those big tasks across sessions.
Claude Might Auto-Stop: When the model reaches the thinking token limit, it will stop reasoning and proceed to answer. Ideally, you want the budget high enough that it doesn’t cut off mid-thought. If you ever see the final answer seemingly abruptly generated or incomplete, that could be a sign the thinking was truncated by budget. Increase it next time. Conversely, if Claude finishes reasoning and still has budget left, it will simply not use the remainder – that’s fine. The budgets are a soft cap, not a target to always hit. Don’t be alarmed if it uses fewer tokens than allowed; that usually means it solved the problem efficiently.
Stay Updated: Extended thinking is a new frontier. Anthropic called the visible thought process in Claude 3.7 a “research preview” and indicated they might change how it’s exposed in future. Indeed, by Claude 4 they moved to summaries by default. Keep an eye on the Claude documentation for updates to this feature – e.g., improvements to the summarizer, changes in how budgets interact with context length, or even new features like “interleaved thinking (beta)” which in the AWS docs hints at the model thinking between tool calls beyond normal limits. Also, research in AI safety and reasoning is ongoing: making chains-of-thought more faithful, or preventing clever jailbreak attempts that exploit the scratchpad, etc. As an advanced user, staying abreast of these developments will help you use thinking mode responsibly and effectively.
In conclusion, Claude’s “thinking mode” – its extended reasoning engine – represents a significant advancement in making AI more intelligent, transparent, and controllable. By letting the model simulate a scratchpad of thoughts, we get the best of both worlds: fast answers when we need them, and deep, step-by-step solutions for the hard stuff. This feature bridges the gap between simple chatbot responses and true problem-solving behavior. Users who master it can unlock Claude’s full potential: whether it’s solving a tough bug after carefully considering multiple approaches, analyzing a 100-page contract and catching subtle details, or planning a complex project with foresight and structure.
With the strategies outlined – from prompt design to tool integration – you should be equipped to engage Claude’s thinking mode in a way that feels like collaborating with a knowledgeable partner who doesn’t mind doing the long division or heavy lifting in the background. As AI models continue to evolve, such hybrid reasoning capabilities may become the norm, but Claude stands out today for giving us a glimpse into an AI’s “thought process.” Using it wisely, we can achieve results that were previously out of reach for machines, all while maintaining a level of insight into why the AI is saying what it does.
Claude’s extended thinking isn’t just about getting better answers – it’s a step towards AI that can reason, not just regurgitate. And as users and developers, having the ability to dial up the reasoning power when needed is a powerful tool in our toolbox. Whether you’re debugging code, researching a tough question, or guiding a chatbot through a tricky conversation, don’t forget you can always say, “Hey Claude, take your time and think this through,” and watch as it unleashes its extended reasoning engine to tackle the task at hand.