Letting Claude Think

What "thinking" buys you

Chain of thought (CoT) means letting the model reason through a problem step by step before committing to an answer, instead of jumping straight to a conclusion. For anything with multiple steps — math, analysis, planning, debugging — reasoning room measurably improves accuracy, because each intermediate step gets checked against the previous one instead of being guessed in a single leap.

The trade is latency and tokens. A model that thinks for two thousand tokens before answering is slower and more expensive than one that answers directly. The skill is knowing when thinking pays for itself and when it's pure overhead.

How thinking works today: adaptive, on by default

This area changed significantly, and older tutorials will mislead you:

• Current Claude models use adaptive thinking (thinking: {type: "adaptive"} in the API). The model decides how deeply to reason based on query complexity, and you steer overall depth with an effort parameter — not by micromanaging a token budget.
• budget_tokens — the old way of capping thinking length — is deprecated, and on Claude 4.7+ models it's an error.
• The Claude Code keyword ladder ("think" < "think hard" < "ultrathink") is deprecated too. Thinking is now on by default; you don't summon it with magic words.

So the modern default is: thinking is available, the model scales it, and you tune the dial (effort) rather than scripting the reasoning.

Prescribe less than you think you should

A tempting habit is writing out the reasoning plan yourself: "First list the variables, then check each constraint, then..." Anthropic's guidance is the opposite: prefer general instructions like "think thoroughly about the edge cases" over prescriptive step-by-step reasoning plans. Claude's own reasoning about how to attack a problem often exceeds what a human would prescribe, and a rigid script prevents the model from taking a better path it can see and you can't.

Give the goal and the quality bar; let the model choose the route.

Interleaved thinking: reasoning between tool calls

For agentic work, the highest-value thinking happens after tool results, not just before the first action. A line like this in your prompt:

After receiving tool results, carefully reflect on their quality and
determine optimal next steps before proceeding.

...turns a reflexive tool-call chain into a deliberate one. This is how Anthropic's own research agents work: the lead agent uses visible thinking to plan which subagents to spawn, and each subagent thinks after every search to judge result quality and refine the next query. Without that reflection step, agents tend to fire the next tool call based on their original plan even when the last result should have changed it.

Manual CoT: the fallback

When thinking is disabled (or on models without it), you can still get structured reasoning manually with tags:

Answer inside <answer> tags. Before answering, reason through the
problem inside <thinking> tags.

The tag separation matters: it lets your code strip the reasoning and show users only the answer. This is a fallback, not the default — adaptive thinking does the same job with less prompt machinery.

Self-checks — and when to remove them

Asking Claude to verify its own work before finishing is a classic accuracy booster:

Before you finish, verify your answer against the test cases and
fix any that fail.

One important caveat: the newest Opus-class models self-verify by default, and prompting them to verify makes them over-verify — re-checking work repeatedly, burning time and tokens. Instructions written for older models can actively hurt newer ones. When you upgrade models, re-test your prompts and strip scaffolding the model no longer needs.

When thinking is worth it

The rule of thumb: thinking helps in proportion to how many ways the task can go wrong midway. One-step tasks have no midway. For those, low effort (or a smaller, faster model) gives the same answer sooner and cheaper.