30 DeepSeek Prompts for Reasoning, Code & Research
Battle-tested prompts for DeepSeek-R1 and DeepSeek-V3 that unlock step-by-step reasoning, clean code, hard math, and deep research — all on a free, open-source model.
In short: This page contains 30 copy-paste ready prompts, organized into 6 categories with a description and pro tip for each. The first 5 prompts are free instantly, no signup needed. Drafted with AI writing assistance and checked against our editorial policy.
Complex Reasoning (R1)
5 promptsMulti-Step Decision Analysis
1/30✨ What it does
DeepSeek-R1 walks through [DECISION YOU NEED TO MAKE] across [OPTION A], [OPTION B], and [OPTION C], then recommends a path toward [DESIRED OUTCOME]. Fill in [BUDGET / TIME / RISK TOLERANCE], then take or reject that recommendation.
<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>
Pro tip: R1 exposes its chain-of-thought — skim the reasoning block to catch any assumption you disagree with before trusting the conclusion.
Root-Cause Diagnosis
2/30✨ What it does
DeepSeek-R1 runs a structured root-cause pass on [WHAT IS GOING WRONG], grouping causes and aiming at a testable hypothesis, not just the symptom. Paste [PRIOR ATTEMPTS] and [TIMING / TRIGGER], then test the top hypothesis in your system.
<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>
Pro tip: Feed R1 raw logs or error text inside the context block — it reasons far better with concrete evidence than with summaries.
Logic Puzzle & Constraint Solver
3/30✨ What it does
DeepSeek-R1 solves your puzzle from [STATE ALL RULES AND FACTS], using a grid and elimination until [WHAT MUST BE DETERMINED] is settled. Check each elimination step, then use the answer only if the grid holds.
<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>
Pro tip: Always keep step 6 (verification) — R1 occasionally races to an answer, and the self-check catches the rare slip.
Steel-Man Both Sides
4/30✨ What it does
DeepSeek-R1 builds the strongest case for and against [THE CONTESTED CLAIM], then names the crux rather than echoing [WHAT YOU CURRENTLY BELIEVE]. Read both cases, then update or keep your lean on purpose.
<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>
Pro tip: Naming your current lean lets R1 deliberately argue harder against you, which surfaces blind spots faster.
Plan a Long-Horizon Goal
5/30✨ What it does
DeepSeek-R1 works backward from [THE OUTCOME YOU WANT] across [WEEKS / MONTHS] into milestones, given [TIME, MONEY, SKILLS, TEAM] and [BLOCKERS]. Edit the first milestone, then put those dates on your calendar.
<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>
Pro tip: Backward planning (working from the goal back to today) consistently exposes hidden dependencies that forward planning misses.
Coding & Building (V3)
5 promptsBuild a Feature From a Spec
6/30✨ What it does
DeepSeek-V3 implements [WHAT IT SHOULD DO] with [DATA IN, DATA OUT] and notes tradeoffs under [PERFORMANCE, STYLE, DEPENDENCIES ALLOWED]. Review the code against your stack, then paste it into the repo and test.
<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>
Pro tip: Use V3 for routine implementation — it is fast and free; reserve R1 for algorithms where correctness depends on careful reasoning.
Refactor for Readability
7/30✨ What it does
DeepSeek-V3 refactors [PASTE CODE] in [LANGUAGE] toward [READABILITY / PERFORMANCE / TESTABILITY] without changing behavior, and lists the smells it cleaned up. Diff the result, then run your tests before you merge.
<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>
Pro tip: Ask it to keep the public interface unchanged so the refactor stays drop-in and you can diff with confidence.
Explain Unfamiliar Code
8/30✨ What it does
DeepSeek-V3 explains [PASTE CODE] at your [BEGINNER / INTERMEDIATE / EXPERT] level so you can [MODIFY / DEBUG / REVIEW] it section by section. Read the walkthrough, then edit only the spots it marks as safe.
<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>
Pro tip: State your skill level honestly — V3 calibrates the depth of explanation, so beginners get more context and experts get less noise.
Design an API or Schema
9/30✨ What it does
DeepSeek-V3 designs a schema or API for [DOMAIN / ENTITIES] covering [READS, WRITES, QUERIES NEEDED] under [VOLUME, LATENCY, STACK]. Mark the fields you will actually store, then implement that shape.
<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>
Pro tip: List your real queries up front — the schema is only as good as the access patterns you give it.
Write Tests for Existing Code
10/30✨ What it does
DeepSeek-V3 writes a test suite for [PASTE CODE] covering the happy path, edges, and [WHAT WORRIES YOU]. Run the suite, then add any case it missed.
<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>
Pro tip: The "could not test" list in step 6 usually reveals tight coupling worth refactoring before you ship.
Debugging & Troubleshooting
5 promptsDiagnose an Error From a Stack Trace
11/30✨ What it does
DeepSeek-R1 translates [PASTE FULL TRACE] into a likely cause and a fix, using [PASTE CODE] plus [EXPECTED] versus [ACTUAL]. Apply the patch in your project, then rerun the failing case.
<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>
Pro tip: Paste the FULL trace, not just the last line — R1 reasons across the call chain to find where things truly went wrong.
Reproduce an Intermittent Bug
12/30✨ What it does
DeepSeek-R1 turns [WHAT FAILS, HOW OFTEN] into a reproducible scenario from [ENVIRONMENT, LOAD, TIMING] and your [OBSERVATIONS]. Follow the reproduction steps, then write a test once it fails on demand.
<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>
Pro tip: Be precise about what is consistent vs random — that contrast is the single biggest clue for classifying intermittent failures.
Performance Bottleneck Hunt
13/30✨ What it does
DeepSeek finds why [OPERATION / PAGE / QUERY] is slow from [PROFILER DATA OR ROUGH NUMBERS] and ranks the highest-impact fix toward [DESIRED LATENCY]. Change the top bottleneck first, then measure again in your profiler.
<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>
Pro tip: Give it real profiler numbers if you have them — guessing at the bottleneck wastes effort; measuring directs it.
Debug Logic, Not Syntax
14/30✨ What it does
DeepSeek-R1 traces [PASTE CODE] with [SAMPLE INPUT], comparing [WHAT IT SHOULD BE] to [WHAT IT IS] until it names the wrong line. Fix that line in your code, then rerun the same input.
<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>
Pro tip: R1’s step-by-step variable trace is its superpower here — it effectively runs the code in its head with your input.
Untangle a Dependency or Build Error
15/30✨ What it does
DeepSeek-V3 decodes [PASTE FULL ERROR] from your [PACKAGE MANAGER, BUILD TOOL, VERSIONS] and gives an ordered command list. Run the commands in order, then rebuild once the error is gone.
<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>
Pro tip: Mention what changed right before the break — most build errors trace directly to the last install or upgrade.
Like these prompts? There are full tutorials behind them.
Learn the workflows, not just the prompts. Easy-to-follow tutorials inside AI Academy, and the library keeps growing.
Math & Data Problems
5 promptsSolve a Math Problem Step by Step
16/30✨ What it does
DeepSeek-R1 solves [STATE THE PROBLEM FULLY] at [ALGEBRA / CALCULUS / STATISTICS / OTHER] with full working, then states the transferable insight. Check each step, then keep the method for your next similar problem.
<context> Model: DeepSeek-R1 (strong at math). Problem: [STATE THE PROBLEM FULLY] Level: [ALGEBRA / CALCULUS / STATISTICS / OTHER] What I want: [JUST THE ANSWER / FULL WORKING / INTUITION] </context> <task> Solve rigorously: 1. Restate the problem and identify the type of math involved. 2. State the relevant formulas or theorems before applying them. 3. Solve step by step, showing every transformation. 4. State the final answer clearly with units. 5. Verify the answer by substitution or an independent method. 6. Explain the key insight in one sentence so I can solve similar problems. </task>
Pro tip: R1 excels at math because it checks its own work — always keep step 5 so a slip in algebra gets caught.
Build a Spreadsheet Formula
17/30✨ What it does
DeepSeek-V3 writes a ready-to-paste formula for [EXCEL / GOOGLE SHEETS] that calculates [THE GOAL] and handles [BLANKS, ERRORS, DUPLICATES TO HANDLE]. Paste it into your sheet, then test a blank row.
<context> Model: DeepSeek-V3. Spreadsheet: [EXCEL / GOOGLE SHEETS] Data layout: [DESCRIBE COLUMNS AND WHAT THEY HOLD] What I need to calculate: [THE GOAL] Edge cases: [BLANKS, ERRORS, DUPLICATES TO HANDLE] </context> <task> Produce the formula: 1. Restate the calculation and the exact cell ranges involved. 2. Give the formula, written to paste directly into the target cell. 3. Explain each part of the formula in plain language. 4. Show how to handle the edge cases I listed. 5. Provide an alternative approach (e.g. helper column) if it is cleaner. 6. Note any version-specific functions that may not work everywhere. </task>
Pro tip: Describe your columns by content, not just letters — "column C = order date" gets a far more reliable formula than "column C".
Interpret a Dataset
18/30✨ What it does
DeepSeek-R1 reads [PASTE DATA], answers [THE QUESTION], and ties the insight to [CONTEXT] with caveats. Use the honest finding in your decision, then ignore any stretch it flagged.
<context> Model: DeepSeek-R1. Data (paste rows or summary stats): [PASTE DATA] What I want to learn: [THE QUESTION] What decision this informs: [CONTEXT] </context> <task> Analyze and interpret: 1. Summarize the dataset: size, fields, and obvious data-quality issues. 2. Compute the relevant statistics for my question (and show the working). 3. Describe the patterns, trends, or outliers you find. 4. State what the data does and does NOT support concluding. 5. Flag any confounders or sampling concerns. 6. Give a one-paragraph answer to my question with appropriate hedging. </task>
Pro tip: Ask explicitly for what the data does NOT support — it keeps the model from overstating weak signals.
Estimate With a Fermi Breakdown
19/30✨ What it does
DeepSeek-R1 estimates the quantity from [ANY REAL NUMBERS YOU HAVE] as a factor chain with a range at [ORDER OF MAGNITUDE / WITHIN 2X]. Swap in better anchors, then treat the range as a planning number.
<context> Model: DeepSeek-R1. Question to estimate: [E.G. MARKET SIZE, COST, VOLUME] Known anchors: [ANY REAL NUMBERS YOU HAVE] Acceptable precision: [ORDER OF MAGNITUDE / WITHIN 2X] </context> <task> Estimate via a structured breakdown: 1. Decompose the quantity into a chain of multiplicable factors. 2. Assign a reasoned value to each factor, citing the basis. 3. Multiply through to get the estimate, showing the arithmetic. 4. Give a low and high bound by varying the most uncertain factor. 5. Identify which single assumption the estimate is most sensitive to. 6. State the final range and your confidence. </task>
Pro tip: The sensitivity step tells you exactly which input to go research first if you want a tighter estimate.
Convert Word Problem to Equations
20/30✨ What it does
DeepSeek-R1 turns [PASTE THE FULL PROBLEM] into named variables, equations, and a checked solution for [THE UNKNOWN]. Verify the units, then use the solved value in your write-up.
<context> Model: DeepSeek-R1. Word problem: [PASTE THE FULL PROBLEM] What is being asked for: [THE UNKNOWN] </context> <task> Formalize and solve: 1. Define every variable with clear notation and units. 2. Translate each sentence of the problem into an equation or constraint. 3. List the full system of equations. 4. Solve the system step by step. 5. Interpret the solution back in the words of the original problem. 6. Sanity-check that the answer is physically or logically reasonable. </task>
Pro tip: Forcing the model to define variables and units first prevents the classic mistake of mixing up what each number represents.
Research & Synthesis
5 promptsStructured Literature Summary
21/30✨ What it does
DeepSeek synthesizes [SUBJECT] from [PASTE ARTICLES / NOTES, OR DESCRIBE WHAT YOU KNOW] into a theme-organized brief for [WHO WILL READ THIS]. Edit the themes, then hand the brief to that reader.
<context> Model: DeepSeek-V3 for breadth; R1 if you need critical synthesis. Topic: [SUBJECT] Material: [PASTE ARTICLES / NOTES, OR DESCRIBE WHAT YOU KNOW] Depth: [OVERVIEW / DETAILED] Audience: [WHO WILL READ THIS] </context> <task> Synthesize the material: 1. State the central question or theme the material addresses. 2. Summarize the main positions or findings, grouped by theme not by source. 3. Highlight where sources agree and where they conflict. 4. Identify gaps or unanswered questions. 5. Write a tight executive summary for my audience. 6. List the 3 most important takeaways. </task>
Pro tip: Grouping by theme rather than by source is what turns a pile of notes into actual synthesis — enforce it in the prompt.
Compare Options Objectively
22/30✨ What it does
DeepSeek scores [OPTION A], [OPTION B], and [OPTION C] against [LIST YOUR CRITERIA] for [CONTEXT THAT AFFECTS THE CHOICE], then recommends one. Adjust the weights, then pick the winner you can live with.
<context> Model: DeepSeek-V3. What I am comparing: [OPTION A] vs [OPTION B] vs [OPTION C] Criteria that matter: [LIST YOUR CRITERIA] My situation: [CONTEXT THAT AFFECTS THE CHOICE] </context> <task> Compare fairly: 1. Confirm the criteria and weight them by importance to my situation. 2. Build a comparison table scoring each option against each criterion. 3. Note the standout strength and biggest weakness of each option. 4. State which option wins overall and for which type of user each is best. 5. Call out any criterion where the "loser" is actually the better pick. 6. Give a one-line recommendation for my specific situation. </task>
Pro tip: Provide your real criteria — a generic comparison is useless; the value comes from weighting against what matters to YOU.
Generate Research Questions
23/30✨ What it does
DeepSeek-R1 maps [TOPIC] into sub-areas and ranked research questions for [PAPER / PRODUCT / CURIOSITY], given [BACKGROUND]. Choose the top questions, then start with the one you can actually answer.
<context> Model: DeepSeek-R1. Topic or area of interest: [TOPIC] What I already know: [BACKGROUND] Purpose: [PAPER / PRODUCT / CURIOSITY] </context> <task> Design a research agenda: 1. Map the topic into 4-6 sub-areas. 2. For each sub-area, generate 2-3 sharp, answerable research questions. 3. Rank all questions by importance and by how tractable they are. 4. Flag which questions are settled vs genuinely open. 5. Suggest the best starting question and what would be needed to answer it. 6. Note adjacent topics worth exploring later. </task>
Pro tip: Ranking questions by tractability as well as importance keeps you from starting with the most exciting but unanswerable one.
Fact-Check and Stress-Test a Claim
24/30✨ What it does
DeepSeek-R1 stress-tests [THE CLAIM] from [WHERE IT CAME FROM] and returns a bounded [VERDICT / NUANCE / COUNTEREVIDENCE]. Read the limits, then only repeat what still holds in your own words.
<context> Model: DeepSeek-R1. Claim to examine: [THE CLAIM] Source or context: [WHERE IT CAME FROM] What I want: [VERDICT / NUANCE / COUNTEREVIDENCE] </context> <task> Critically evaluate the claim: 1. Restate the claim precisely and identify what would make it true or false. 2. Separate the factual parts from the interpretive or opinion parts. 3. Reason through the evidence for and against based on what is well established. 4. Flag where the claim is overstated, cherry-picked, or context-dependent. 5. State a calibrated verdict (true / mostly true / misleading / false / unverifiable). 6. Note clearly the limits of what you can assess without live sources. </task>
Pro tip: DeepSeek has no live web access, so step 6 matters — treat its verdict as reasoning over known facts, then verify time-sensitive claims yourself.
Turn Research Into an Outline
25/30✨ What it does
DeepSeek-V3 turns [PASTE] into a writing-ready outline for a [REPORT / ARTICLE / PRESENTATION] aimed at [WHO], with gaps flagged. Fill the gaps, then write your draft from that structure.
<context> Model: DeepSeek-V3. Deliverable: [REPORT / ARTICLE / PRESENTATION] Key findings or notes: [PASTE] Audience: [WHO] Length target: [WORDS / SLIDES] </context> <task> Build a writing-ready outline: 1. Define the single core message the deliverable must land. 2. Propose a logical structure (sections or slides) that serves that message. 3. Under each section, slot the relevant findings and note what is still missing. 4. Suggest the strongest opening hook and the closing takeaway. 5. Estimate length per section against my target. 6. Flag the section most likely to need more research before writing. </task>
Pro tip: Having it flag the weakest section forces you to fill gaps before drafting instead of discovering them mid-write.
Go from copy-pasting to actually mastering AI.
AI Academy: hands-on tutorials on ChatGPT, Claude, Midjourney, and many other tools. New tutorials are added regularly.
Cost-Free Heavy Workloads
5 promptsBatch-Process Many Items
26/30✨ What it does
DeepSeek-V3 applies [WHAT TO DO TO EACH ITEM] to [PASTE LIST OR DATASET] and returns a uniform [TABLE / JSON / BULLETS] under [CONSTRAINTS]. Spot-check a few rows in your list, then use the batch.
<context> Model: DeepSeek-V3 (fast and free — ideal for volume). Task to repeat: [WHAT TO DO TO EACH ITEM] Items: [PASTE LIST OR DATASET] Output format: [TABLE / JSON / BULLETS] Rules to apply uniformly: [CONSTRAINTS] </context> <task> Process every item consistently: 1. Confirm the task and the output schema before starting. 2. Apply the task to each item in order, with no skipped items. 3. Keep formatting identical across all items. 4. Flag any item that is ambiguous rather than guessing silently. 5. Output the full batch in the requested format. 6. End with a count of items processed and any flagged for review. </task>
Pro tip: DeepSeek’s free, low-cost inference makes it the right model for high-volume batch jobs you would never run on a premium API.
Long-Document Summarization
27/30✨ What it does
DeepSeek-V3 summarizes [PASTE LONG TEXT] for the [DECISIONS / FACTS / ACTION ITEMS] you need, at your [TARGET] length. Confirm the facts you will act on, then file the short version.
<context> Model: DeepSeek-V3 (large context, free). Document: [PASTE LONG TEXT] What I need from it: [DECISIONS / FACTS / ACTION ITEMS] Summary length: [TARGET] </context> <task> Summarize without losing what matters: 1. Identify the document type and its purpose. 2. Extract the key points relevant to what I need, in order of importance. 3. Pull out any numbers, dates, names, or commitments verbatim. 4. Note anything surprising or that contradicts the main thrust. 5. Write the summary at my target length. 6. List any section too dense to compress that I should read in full. </task>
Pro tip: Tell it what you need the summary FOR — a summary for a decision keeps different details than one for a record.
Draft, Then Self-Review at Scale
28/30✨ What it does
DeepSeek-V3 drafts [WHAT TO WRITE] from [FACTS, TONE, CONSTRAINTS], then critiques it against [WHAT GOOD LOOKS LIKE] and revises. Apply the edits you agree with, then ship the second pass.
<context> Model: DeepSeek-V3 to draft, then ask it to switch to a critical reviewer. Deliverable: [WHAT TO WRITE] Key inputs: [FACTS, TONE, CONSTRAINTS] Quality bar: [WHAT GOOD LOOKS LIKE] </context> <task> Do this in two passes: PASS 1 — Draft: Write a complete first draft that meets the constraints. PASS 2 — Critique: Now act as a skeptical reviewer. List the 5 weakest points of the draft against my quality bar. PASS 3 — Revise: Rewrite the draft fixing each weakness. Output only the final version. </task>
Pro tip: Because DeepSeek is free to run, you can afford this draft-critique-revise loop on every piece without burning a paid quota.
Generate Many Variations
29/30✨ What it does
DeepSeek-V3 produces [NUMBER OF VARIATIONS] along [TONE / LENGTH / ANGLE / AUDIENCE], keeping [MUST-KEEP ELEMENTS]. Label the spread, then choose the one you will actually use.
<context> Model: DeepSeek-V3. Base asset: [THE THING TO VARY — HEADLINE, EMAIL, NAME, ETC.] Dimension to vary: [TONE / LENGTH / ANGLE / AUDIENCE] How many: [NUMBER OF VARIATIONS] Constraints: [MUST-KEEP ELEMENTS] </context> <task> Produce diverse variations: 1. Restate the base asset and the must-keep elements. 2. Generate the requested number of genuinely distinct variations along the dimension. 3. Label each with the specific angle or tone it represents. 4. Avoid near-duplicates — each should be meaningfully different. 5. Recommend the top 2 and explain why. 6. Note which variation is safest and which is the boldest bet. </task>
Pro tip: Specify the dimension to vary (tone, angle, length) — otherwise the variations cluster together instead of spanning the space.
Iterative Coding Session Setup
30/30✨ What it does
DeepSeek-V3 sets up a verify-as-you-go loop for [WHAT YOU ARE BUILDING], from [WHAT EXISTS SO FAR] toward [WHAT TO ADD OR FIX]. Follow one step, run it, then ask for the next only after it works.
<context> Model: DeepSeek-V3 for iteration speed; R1 for the hard parts. Project: [WHAT YOU ARE BUILDING] Current state: [WHAT EXISTS SO FAR] Next goal: [WHAT TO ADD OR FIX] Stack and conventions: [LANGUAGES, STYLE] </context> <task> Set up a productive iteration loop: 1. Confirm your understanding of the current state and the next goal. 2. Break the goal into 3-6 small, individually testable steps. 3. Implement the first step only, with a way to verify it works. 4. After I confirm it works, proceed to the next step. 5. Keep code consistent with my stated conventions throughout. 6. At the end, summarize what changed and what is left. </task>
Pro tip: Building in small verifiable steps plus DeepSeek’s zero-cost inference lets you iterate aggressively without worrying about token spend.
Free tool
Prompt Optimizer
Turn a rough idea into a structured, professional AI prompt.
Frequently Asked Questions
Prompts are the starting line. Tutorials are the finish.
A growing library of hands-on tutorials on ChatGPT, Claude, Midjourney, and many other AI tools. New tutorials are added regularly.
7-day free trial. Cancel anytime.
Related guides