How to Prompt DeepSeek for Reasoning (2026): Formulas + Examples

To get strong reasoning out of DeepSeek, do two things: turn on DeepThink, and structure the prompt as Problem → Context → Constraints → Reason → Verify. State the real problem, paste the real data, list the logical constraints the answer must satisfy, ask it to reason step by step, and make it check the result before it commits. DeepSeek-V3.2 (Dec 2025) is a free, open-source (MIT) model with a 128K context window and gold-medal-level math and reasoning, comparable to GPT-5-class models — but it reasons best when you hand it a hard problem, not a rigid format.

This guide covers the DeepThink toggle, the five-part formula, the golden rule that makes the difference, ten copy-paste prompts, and the mistakes that quietly wreck reasoning. For the broader set, start with the best DeepSeek prompts roundup, and keep the DeepSeek prompt cheat sheet open as a one-pager.

Turn on DeepThink first

DeepThink is the reasoning toggle, corresponding to the R1-style line. With it on, DeepSeek exposes its full chain-of-thought before the final answer. That trace is the whole point: reading it lets you catch a wrong assumption early, before you trust the conclusion. If the model misreads a number in step two, you see it in step two instead of debugging a wrong final answer.

DeepSeek also offers two depth modes. Instant is fast with no visible reasoning — good for lookups, simple rewrites, and quick answers. Expert reasons more deeply and is the one you want for anything hard. For serious reasoning, pair Expert with DeepThink so you get both depth and a readable trace. Flip on the Search toggle when the problem depends on current facts, and use file upload to hand DeepSeek a full problem set instead of retyping it.

Rule of thumb: if you would need scratch paper to solve it yourself, turn on DeepThink. If a fast lookup would do, leave it off and save the wait.

The reasoning formula: Problem → Context → Constraints → Reason → Verify

Every strong reasoning prompt has the same five parts. Miss one and the answer gets weaker in a predictable way.

• Problem — state exactly what you want solved, in one plain sentence. No preamble.
• Context — paste the real data, code, numbers, or text. DeepSeek reasons over what you give it; a summary throws away the detail it needs.
• Constraints — the logical rules the answer must satisfy (budget, limits, definitions, allowed moves). These are guardrails for the reasoning, not formatting rules.
• Reason — tell it to think step by step, define its variables, state assumptions, and consider at least one alternative method and explain its choice.
• Verify — require it to check the final answer against the constraints and plug it back into the problem before giving the result.

Here is the difference the formula makes. Before, a thin prompt:

A train leaves at 3pm going 60mph and another leaves at 4pm going 80mph. When do they meet? Give me the answer in a table.

After, the same problem run through the formula (with DeepThink on):

Problem: Find the time two trains meet.
Context: Train A leaves Station X at 3:00pm heading toward Station Y at 60 mph. Train B leaves Station Y at 4:00pm heading toward Station X at 80 mph. The stations are 300 miles apart. They travel toward each other on parallel tracks.
Constraints: Assume constant speeds and no stops. Distances add to 300 miles at the meeting time.
Reason: Define your variables, state your assumptions, and think step by step. Consider solving it two ways (algebraically and by a distance table) and explain which you trust more.
Verify: Before giving the final time, plug it back in and confirm the two distances sum to 300 miles. State the exact clock time.

The second prompt drops the format demand and adds the missing distance, the constraints, and a verify step — which is what actually produces a correct, checkable answer.

The golden rule: hard problem, not rigid formatting

Give DeepSeek a hard problem and rich context, not rigid formatting rules. Over-constraining the format — "answer in exactly three bullets," "one word only," "fill this template" — shrinks the space the model reasons in. It spends effort satisfying your layout instead of solving the problem, and the reasoning suffers.

Instead, load the prompt with logical constraints and let DeepSeek find the path. Ask for the format afterward, in a follow-up, once the answer is right. Compare these two openers on the same task:

In one sentence, no working shown, tell me the optimal price for [PRODUCT].

That forces a guess. This gives it room to reason:

Problem: Recommend a price for [PRODUCT].
Context: Cost per unit [COST]. Competitor prices [LIST]. Demand notes: [WHAT YOU KNOW]. Goal: maximize profit over 12 months.
Constraints: Price must stay above cost and within [RANGE]. Account for how demand likely changes with price.
Reason: Think step by step, model the trade-off between margin and volume, and consider at least two candidate prices before choosing.
Verify: Check your recommendation against the constraints and explain why it beats the alternatives you considered.

Same question. The second one gets a defensible number because it was allowed to think first and format never.

10 reasoning prompts to copy

Run each of these with DeepThink on and Expert mode selected. Swap anything in [BRACKETS] for your own details, and paste your real numbers and text where noted.

1. Multi-step word problem

Problem: Solve this word problem: [PASTE PROBLEM].
Context: [ANY EXTRA NUMBERS OR CONDITIONS].
Reason: Define every variable, state your assumptions, and work through it step by step. Do not skip arithmetic.
Verify: Substitute your final answer back into the original problem and confirm every condition holds. If it doesn't, find the error and redo that step.

Why it works: The substitute-back verify step catches the arithmetic slip that wrecks most multi-step answers.

2. Logic puzzle

Problem: Solve this logic puzzle: [PASTE PUZZLE].
Constraints: Every clue must be satisfied simultaneously. No guessing — each deduction must follow from a stated clue.
Reason: Build a grid or table of possibilities, eliminate options one clue at a time, and show which clue forces each elimination.
Verify: Re-read every clue against your final solution and confirm none is violated.

Best for: Grid puzzles and constraint problems where one skipped clue breaks everything.

3. A proof

Problem: Prove the following statement: [STATEMENT].
Context: Assume [KNOWN FACTS / DEFINITIONS you're allowed to use].
Reason: State your proof strategy first (direct, contradiction, induction) and why you chose it. Then write each step so it follows rigorously from the previous one, justifying every non-trivial move.
Verify: Re-check that no step assumes what you're trying to prove, and confirm the conclusion actually follows.

Why it works: Asking it to name the strategy and choose it prevents the hand-wavy leaps that ruin AI proofs.

4. Probability

Problem: Find the probability of [EVENT] given [SETUP].
Constraints: State clearly whether events are independent, mutually exclusive, or conditional before computing.
Reason: Define the sample space, show the counting or formula you use, and compute step by step. Consider one alternative method (e.g., complement) and explain your choice.
Verify: Confirm your answer is between 0 and 1 and sanity-check it against a simpler related case.

Best for: Conditional and combinatorial problems where the wrong independence assumption sinks the answer.

5. Optimization / trade-off decision

Problem: Choose the option that best achieves [OBJECTIVE].
Context: Options and their data: [PASTE OPTIONS WITH NUMBERS].
Constraints: Must satisfy [HARD LIMITS]. Optimize for [WHAT MATTERS MOST], then [SECONDARY].
Reason: Model the trade-off explicitly, score each option against the objective, and think step by step about second-order effects.
Verify: Confirm the winner meets every hard limit and explain why it beats the runner-up.

Why it works: Separating hard limits from soft objectives lets DeepSeek reason about the trade-off instead of averaging everything.

6. Debugging logic in code

Problem: This code produces the wrong output. Find the logic error: [PASTE CODE].
Context: Expected output: [EXPECTED]. Actual output: [ACTUAL]. Language/version: [LANG].
Reason: Trace the execution step by step with the failing input, tracking each variable's value, until the point where reality diverges from what's expected.
Verify: Give the fix, then re-run the trace mentally with the fix in place and confirm it now produces the expected output.

Best for: Silent logic bugs where nothing crashes but the numbers are wrong. For more, see the DeepSeek coding prompts.

7. Analyzing an argument for fallacies

Problem: Analyze this argument for logical soundness: [PASTE ARGUMENT].
Reason: Lay out the argument's premises and conclusion explicitly. For each step, decide whether the conclusion actually follows. Name any fallacies (with the specific type) and any unstated assumptions it relies on.
Verify: Separate what's genuinely wrong with the logic from what you merely disagree with, and state the single weakest link.

Why it works: Forcing it to split logic flaws from personal disagreement keeps the analysis honest.

8. Fermi estimate

Problem: Estimate [QUANTITY] from first principles: [WHAT TO ESTIMATE].
Reason: Break it into factors you can each estimate, state your assumption and rough number for each, and multiply through step by step. Keep units explicit.
Verify: Sanity-check the final order of magnitude against anything you know, and state a plausible range rather than a single false-precise number.

Best for: Ballpark market-size, capacity, or "how many" questions where a defensible order of magnitude beats a wild guess.

9. Comparing two options with a verify step

Problem: Decide between [OPTION A] and [OPTION B] for [DECISION].
Context: What I know about each: [PASTE DETAILS]. What I care about: [PRIORITIES].
Reason: Compare them against each priority in turn, weighting by how much each matters to me, and reason step by step toward a recommendation.
Verify: Argue the opposite case for one paragraph, then confirm whether your recommendation still holds after considering it.

Why it works: Making it argue the other side is a verify step that surfaces the weakness in a too-quick recommendation.

10. Planning problem with constraints

Problem: Build a plan/schedule to achieve [GOAL].
Context: Tasks, durations, and dependencies: [PASTE]. Resources available: [PASTE].
Constraints: Deadline [DATE]. [ANY HARD RULES — no double-booking, order dependencies, budget].
Reason: Order the tasks respecting every dependency, allocate resources step by step, and flag the critical path.
Verify: Walk the finished plan against each constraint and confirm none is violated; if one is, adjust and re-check.

Best for: Scheduling and sequencing problems where dependencies and hard limits interact. See the reasoning and math prompts for more in this vein.

Mistakes to avoid

• Over-formatting the prompt. Rigid layout demands shrink the reasoning. Ask for the shape of the answer later, once the logic is right.
• Not turning on DeepThink. Without it you lose the chain-of-thought and can't catch a wrong assumption. Turn it on for anything hard.
• Summarizing instead of pasting real data. A paraphrase strips the detail DeepSeek reasons over. Paste the actual numbers, code, or text — or upload the file.
• No verify step. Without an explicit "check it against the constraints" instruction, the model rarely catches its own slip.
• Trusting the answer without reading the reasoning. The trace is there so you can spot the flawed step. Skim it before you rely on the conclusion.
• Using Search-worthy facts without turning on Search. If the answer depends on current data, flip on Search or the model will reason from a stale memory.

Get those six right and the formula does the rest. Bookmark the DeepSeek prompt cheat sheet for the one-page version, and the best DeepSeek prompts roundup for the full library.