Give Thinking Room for Math, Logic, and Constraints

Turning extended thinking on for the class of problems that reward working through steps: multi-step arithmetic, logic and constraint puzzles, unit conversions, anything where a single wrong intermediate step silently poisons the final answer. These are the tasks where 'show the work' actually changes the result.

For reasoning-heavy problems, the answer is only as good as the intermediate steps, and skipping them is where errors hide — a dropped carry, a mis-applied constraint, a sign flip. Extended thinking gives Claude space to lay those steps out and, crucially, to catch its own slip partway through rather than committing to a fast wrong leap. The visible chain also lets you verify by checking steps, not by re-deriving the whole thing. Room to reason isn't a luxury here; it's what makes the answer trustworthy.

Calculations with several dependent steps, logic and scheduling puzzles, problems with interacting constraints, anything numeric where being 'close' isn't good enough. Also when a quick answer to such a problem looked plausible but you couldn't tell if it was right.

Recall, lookup, or single-step arithmetic where thinking adds latency without changing the answer. And thinking is not a substitute for a calculator or code on truly heavy computation — for that, have Claude write and run code instead.

Solve this step by step with extended thinking. Show each intermediate result, carry units through explicitly, and state the constraints you're satisfying as you go. Before giving the final answer, sanity-check it against the original numbers. Problem: <the problem>.

Given a logistics puzzle — three trucks, differing capacities and time windows, a delivery schedule to satisfy — a rushed answer violates a window no one notices. With thinking on, Claude lays out each assignment against each constraint, catches that truck B can't make the 2pm slot, and reworks it before answering. The visible steps let you confirm the schedule actually holds.

For genuinely heavy or exact computation, combine thinking with code: have Claude reason about the approach in its thinking, then write and run a small script for the arithmetic itself. Reasoning decides the method; code guarantees the numbers — which sidesteps the fact that no language model is a reliable calculator at scale.

• Trusting a fast, unshown numeric answer on a multi-step problem where one silent slip changes everything.
• Using thinking as a stand-in for actual computation on large or precise calculations — reach for code instead.
• Not re-checking the final answer against the starting numbers, so an early error rides all the way to the result.