30 DeepSeek Prompts for Reasoning, Code & Research

<context> Model: Use DeepSeek-R1 (reasoning mode). Decision: [DECISION YOU NEED TO MAKE] Options under consideration: [OPTION A], [OPTION B], [OPTION C] Constraints: [BUDGET / TIME / RISK TOLERANCE] What success looks like: [DESIRED OUTCOME] </context> <task> Reason through this decision step by step: 1. Restate the decision and the real underlying goal in one sentence. 2. For each option, list concrete pros, cons, and the key assumption it depends on. 3. Identify the single biggest risk for each option and how likely it is. 4. Weight the options against my constraints and score each 1-10 with justification. 5. Recommend one option, then argue the strongest case AGAINST your own recommendation. 6. End with a 3-step action plan to start. Show your full reasoning before the final answer. </task>

<context> Model: DeepSeek-R1. Problem observed: [WHAT IS GOING WRONG] When it started: [TIMING / TRIGGER] What I have already tried: [PRIOR ATTEMPTS] System or process involved: [DESCRIBE] </context> <task> Find the root cause, not just the symptom: 1. List every plausible cause, grouped by category (input, process, environment, human). 2. For each cause, state what evidence would confirm or rule it out. 3. Rank causes by likelihood given what I already tried. 4. Walk through a 5-Whys chain for the top candidate. 5. Propose the single cheapest test that would isolate the true cause. 6. Give the fix once the cause is confirmed. </task>

<context> Model: DeepSeek-R1. Puzzle or constraints: [STATE ALL RULES AND FACTS] Goal: [WHAT MUST BE DETERMINED] </context> <task> Solve this systematically: 1. Restate every constraint as a formal rule. 2. Set up a grid or table of all entities and possible values. 3. Apply constraints one at a time, eliminating impossible combinations and showing each deduction. 4. Flag the moment the solution becomes uniquely determined. 5. State the final answer. 6. Verify the answer satisfies every original constraint, listing each check. </task>

<context> Model: DeepSeek-R1. Claim or question: [THE CONTESTED CLAIM] My current lean: [WHAT YOU CURRENTLY BELIEVE] Context I am missing: [ANY KNOWN GAPS] </context> <task> Reason fairly through both sides: 1. Build the strongest possible case FOR the claim, with its best supporting evidence. 2. Build the strongest possible case AGAINST it, equally seriously. 3. Identify the crux — the one fact or value that would decide the issue. 4. State which side the available evidence actually favors and how confidently. 5. List what new information would most change your conclusion. </task>

<context> Model: DeepSeek-R1. Goal: [THE OUTCOME YOU WANT] Time horizon: [WEEKS / MONTHS] Resources available: [TIME, MONEY, SKILLS, TEAM] Known obstacles: [BLOCKERS] </context> <task> Reason backward from the goal to a plan: 1. Define what "done" measurably looks like. 2. Work backward: list the milestones that must be true the week before completion, then the month before, and so on. 3. For each milestone, note dependencies and the riskiest assumption. 4. Sequence everything into a phased timeline with checkpoints. 5. Identify the two leverage points where effort matters most. 6. Output the plan as a milestone table with dates and owners. </task>

<context> Model: DeepSeek-V3 (chat) for speed; switch to R1 if the logic is tricky. Language / framework: [E.G. PYTHON, REACT, GO] Feature: [WHAT IT SHOULD DO] Inputs and outputs: [DATA IN, DATA OUT] Constraints: [PERFORMANCE, STYLE, DEPENDENCIES ALLOWED] </context> <task> Implement this feature: 1. Restate the requirements and list any ambiguities you are assuming away. 2. Propose the overall approach in 2-3 sentences before coding. 3. Write clean, idiomatic, commented code. 4. Include input validation and edge-case handling. 5. Add 3-5 unit tests covering normal, edge, and error cases. 6. Note any tradeoffs and one alternative approach. </task>

<context> Model: DeepSeek-V3. Language: [LANGUAGE] Code to refactor: [PASTE CODE] Goals: [READABILITY / PERFORMANCE / TESTABILITY] </context> <task> Refactor without changing behavior: 1. Summarize what the code currently does in plain language. 2. List the specific smells (naming, duplication, long functions, deep nesting). 3. Provide the refactored version, preserving all existing behavior. 4. Explain each meaningful change and why it helps. 5. Flag anything that looks like a latent bug, separately from the refactor. 6. Confirm the public interface is unchanged. </task>

<context> Model: DeepSeek-V3. Code: [PASTE CODE] My level: [BEGINNER / INTERMEDIATE / EXPERT] What I need to do with it: [MODIFY / DEBUG / REVIEW] </context> <task> Explain this code so I can work with it: 1. Give a one-paragraph overview of what it does. 2. Walk through it section by section in execution order. 3. Explain any non-obvious idioms, libraries, or patterns. 4. Draw the data flow (inputs to outputs) in a short list. 5. Point out the spots I am most likely to break if I edit it. 6. Suggest where to safely make the change I described. </task>

<context> Model: DeepSeek-V3. What I am modeling: [DOMAIN / ENTITIES] Key operations: [READS, WRITES, QUERIES NEEDED] Scale and constraints: [VOLUME, LATENCY, STACK] </context> <task> Design the interface: 1. Identify the core entities and their relationships. 2. Propose the schema or endpoint structure with field names and types. 3. Define each operation: method, inputs, outputs, error cases. 4. Note indexing, validation, and pagination decisions. 5. Call out the two design choices most likely to need revisiting at scale. 6. Provide an example request/response for the most common operation. </task>

<context> Model: DeepSeek-V3. Language / test framework: [E.G. JEST, PYTEST] Code under test: [PASTE CODE] Known risky behaviors: [WHAT WORRIES YOU] </context> <task> Generate a thorough test suite: 1. Identify every distinct behavior and branch in the code. 2. Write tests for the happy path first. 3. Add edge cases: empty, null, boundary, and large inputs. 4. Add failure cases that should raise or return errors. 5. Use clear, descriptive test names that read as specifications. 6. List any behavior you could NOT test and why. </task>

<context> Model: DeepSeek-R1 (reasoning helps with tricky bugs). Language / runtime: [LANGUAGE, VERSION] Error message / stack trace: [PASTE FULL TRACE] Relevant code: [PASTE CODE] What I expected vs what happened: [EXPECTED] / [ACTUAL] </context> <task> Find and fix the bug: 1. Translate the error message into plain English. 2. Trace the failure back through the stack to the originating line. 3. State the most likely root cause and your confidence level. 4. List 2-3 alternative causes worth checking if the first is wrong. 5. Provide the corrected code with the change highlighted. 6. Suggest one guard or test that would have caught this earlier. </task>

<context> Model: DeepSeek-R1. Symptom: [WHAT FAILS, HOW OFTEN] Conditions when it appears: [ENVIRONMENT, LOAD, TIMING] What is consistent vs random: [OBSERVATIONS] Code or config involved: [PASTE] </context> <task> Help me make this bug reproducible: 1. List the categories of intermittent bug (race condition, state leak, resource limit, external dependency, timing). 2. Map my symptoms to the most likely categories. 3. For each candidate, describe a minimal scenario that would trigger it reliably. 4. Propose logging or instrumentation to confirm the hypothesis. 5. Once confirmed, give the fix and explain why it eliminates the nondeterminism. </task>

<context> Model: DeepSeek-V3, escalate to R1 for algorithmic analysis. What is slow: [OPERATION / PAGE / QUERY] Measured timing: [PROFILER DATA OR ROUGH NUMBERS] Code or query: [PASTE] Target: [DESIRED LATENCY] </context> <task> Find and remove the bottleneck: 1. Identify the most expensive operation based on the data I gave you. 2. Explain WHY it is expensive (algorithmic complexity, I/O, N+1, allocation). 3. Rank fixes by impact-to-effort ratio. 4. Provide the optimized code for the top fix. 5. Estimate the expected improvement and how to measure it. 6. Warn about any correctness or readability cost of the optimization. </task>

<context> Model: DeepSeek-R1. The code runs but gives the wrong result. Code: [PASTE CODE] Input used: [SAMPLE INPUT] Expected output: [WHAT IT SHOULD BE] Actual output: [WHAT IT IS] </context> <task> Find the logic error: 1. Trace the code line by line with my sample input, tracking variable values. 2. Identify the exact line where the actual diverges from the expected. 3. Explain the flawed assumption behind that line. 4. Provide the corrected line and the reasoning. 5. Suggest one additional test input that would expose this class of bug. </task>

<context> Model: DeepSeek-V3. Tooling: [PACKAGE MANAGER, BUILD TOOL, VERSIONS] Error output: [PASTE FULL ERROR] What changed recently: [NEW PACKAGE / UPGRADE / NOTHING] OS / environment: [DETAILS] </context> <task> Resolve the build or dependency failure: 1. Decode what the error is actually complaining about. 2. Identify the most common causes of this specific error. 3. Give the exact commands or config changes to try, in order of likelihood. 4. Explain how to tell if each step worked. 5. Provide a clean-slate recovery option if the targeted fixes fail. 6. Suggest how to prevent this class of error going forward. </task>