40 Best Claude Prompts (2026)

Act as my chief of staff. Turn my brain-dump into an organized action plan.

Here is everything on my mind right now:
<braindump>
[paste your unsorted notes, tasks, and half-formed ideas]
</braindump>

Do this:
- Group the items into themes and label each theme.
- Tag every item as a task, an idea, or a question.
- List the 3 highest-leverage tasks to do first, and why.
- End with the information you'd need from me to go further.
Keep it scannable with short bullets.

Prepare me for a meeting so I walk in ready.

The meeting is [topic] with [who is attending and their roles]. My goal is [what I want out of it].
Background:
<background>
[paste agenda, prior notes, or the email thread]
</background>

Give me:
- A 5-line situation summary.
- 3 outcomes to push for and 3 objections to expect, with a one-line response to each.
- 5 sharp questions I should ask.
- Anything I'm missing that could derail the meeting.

Help me plan a realistic, high-impact week.

My goals this week: [goals].
My tasks and deadlines:
<tasks>
[paste tasks with any due dates]
</tasks>
I have roughly [X] focused hours per day.

Do this:
- Rank tasks by impact vs. effort and explain the ranking in one line each.
- Build a day-by-day plan that fits my available hours — do not overload any day.
- Tell me what to drop or delegate if it won't all fit.

Summarize a long document for a busy reader.

The reader is [role] who cares most about [their priority].
<document>
[paste or attach the report / contract / PDF / transcript]
</document>

Give me:
- A 3-sentence executive summary first.
- The 7 key points as bullets, in priority order.
- Every number, date, deadline, and commitment pulled out verbatim.
- The 2-3 questions this document leaves unanswered.

Help me make a defensible decision and write it up. Think step by step before answering.

The decision is [decision]. My options:
<options>
[Option A]
[Option B]
[Option C]
</options>
What I care about: [budget, timeline, risk, team, etc.].

Do this:
- Score each option against my constraints in a table.
- Give a clear recommendation with your reasoning.
- Write a one-page decision memo I can send to my manager.
- List the top 2 risks of the recommended option and how to reduce them.

Turn a meeting transcript into a clear follow-up.

<transcript>
[paste the Zoom / Teams / Otter transcript]
</transcript>

Give me:
- A 5-bullet summary of what was decided.
- Every action item as: owner — task — due date (mark "unassigned" or "no date" where missing).
- Any disagreements or unresolved questions.
- A short recap email I can send to attendees.

Be my thinking partner on a decision, not a cheerleader.

Here's what I'm weighing:
<situation>
[describe the situation, what you're leaning toward, and why]
</situation>

Do this:
- Ask me up to 3 clarifying questions first if anything important is missing.
- Then reflect back what you think my real goal is.
- Push back where my reasoning is weak or I'm avoiding something.
- Offer one option I probably haven't considered.
Be direct and honest; I'd rather be challenged than flattered.

Draft a reply in my voice.

I need to reply to [sender] about [subject]. My goal for the reply is [goal]. Tone: [warm and professional / direct / apologetic].
The thread so far:
<thread>
[paste the email thread]
</thread>

Constraints:
- Under 150 words.
- Address every open question in the thread.
- Don't invent facts — if you need something I haven't given, leave a [bracketed placeholder].
- Give me two versions: one concise, one slightly warmer.

Rewrite my text in a specific tone without changing the meaning.

<draft>
[paste text]
</draft>
Target tone: [confident and warm / formal / plain and direct].
Audience: [who reads this].

Constraints:
- Preserve every fact and the original intent.
- Cut filler, hedging, and throat-clearing.
- Give me the rewrite, then a one-line note on what you changed and why.

Act as a strict line editor. Make this sharper without making it sound like AI.

<text>
[paste your draft]
</text>

Do this:
- Tighten every sentence; cut words that earn nothing.
- Kill clichés, hedging, and corporate filler.
- Keep my voice and any deliberate quirks.
- Show the edited version, then list the 3 biggest changes and why.
Do not add new claims or facts.

Outline a blog post that's actually useful.

Topic: [topic]. Audience: [who it's for and their level]. Search intent I'm targeting: [what the reader wants].

Give me:
- A working title and 2 alternates.
- An H2/H3 outline with a one-line note on what each section covers.
- Where to add an example, a checklist, or a table.
- The 3 questions the piece must answer to be worth publishing.

Write a first draft from my rough notes.

Piece: [blog post / newsletter / LinkedIn post / section]. Audience: [who]. Desired length: [words].
My notes and the points I must hit:
<notes>
[paste your bullet points, quotes, and links]
</notes>

Constraints:
- Use only what's in my notes — don't invent facts or stats.
- Match this style: [plain and direct / warm / punchy]. No clichés, no "in today's world" openers.
- Open with a concrete hook, not a definition.
- Leave [bracketed placeholders] where I still need to add something.

Cut this down to a target length.

<text>
[paste text]
</text>
Target length: [100 words / a single paragraph / a tweet].

Constraints:
- Keep every essential fact and the core argument.
- Remove repetition, hedging, and throat-clearing.
- Add nothing new.
- Show the trimmed version and the final word count.

Act as a staff engineer doing a careful review. Think step by step.

Language/framework: [e.g. Python 3.12 / React]. What it should do: [behavior].
<code>
[paste the code]
</code>

Do this:
- List concrete bugs and edge cases, most severe first, each with the line and a fix.
- Flag security issues, race conditions, and unhandled errors.
- Suggest 3 tests that would catch these.
- Don't rewrite the whole file — point to the specific changes.

Diagnose and fix an error. Think step by step before answering.

<error>
[paste the full error and stack trace]
</error>
<code>
[paste the relevant code]
</code>
Expected: [what should happen]. Actual: [what happens].

Do this:
- Give the most likely root cause first, then 2 alternates.
- Provide the exact fix and where it goes.
- Tell me how to confirm it's resolved.

Help me understand a codebase I just inherited.

I'm a [your level] developer new to this project.
<code>
[paste files, a module, or the whole small repo]
</code>

Give me:
- A high-level map: the main components and how they connect.
- One full request/data flow traced from entry point to output.
- The 5 files I should read first, and why.
- Anything that looks fragile, outdated, or unusual.

Write a well-tested function from a spec.

Language: [language]. The function should [inputs -> behavior -> outputs]. It must handle [edge cases].

Constraints:
- Clean, commented code following [style/convention].
- Include input validation and clear error handling.
- Add unit tests covering the happy path and every edge case I listed.
- Explain any non-obvious decision in one line.
Put the code in an Artifact so I can iterate on it.

Build a working single-file app as an Artifact.

What it does: [describe the tool, e.g. a tip calculator / a markdown-to-HTML converter / a habit tracker].
Users: [who] on [mobile / desktop].

Constraints:
- One self-contained HTML file with inline CSS and JS — no external dependencies.
- Clean, responsive UI; sensible defaults; handle empty and error states.
- Render it as an Artifact so I can preview it.
- After it works, list 3 features I could add next.

Refactor this code for readability without changing behavior.

<code>
[paste the code]
</code>

Do this:
- Keep the exact same inputs and outputs — behavior must not change.
- Improve naming, structure, and duplication; add comments only where they earn it.
- Show the refactored version, then a short list of what you changed and why.
- Flag anything that looked like a latent bug while you were in there.

Build a regex I can trust.

I need to match [describe the pattern] in [language/flavor, e.g. JavaScript, PCRE].
<should_match>
[list examples that SHOULD match]
</should_match>
<should_not_match>
[list examples that should NOT match]
</should_not_match>

Do this:
- Give the final regex and a plain-English breakdown of each part.
- Show it passing every match example and rejecting every non-match example.
- Note any edge case it won't handle.

Research a topic and give me a sourced brief. Use web search for anything current.

Question: [specific question]. Purpose: [the decision or output this feeds]. What I already know: [context].

Give me:
- Current state, key players/options, trade-offs, and what's changed recently.
- A comparison table where it helps.
- Sources cited with links for every factual claim.
- A clear recommendation and the 3 open questions worth more digging.
Flag anything you're unsure about instead of guessing.

Compare my options using up-to-date information. Use web search and cite sources.

I'm choosing between [Option A], [Option B], and [Option C] for [purpose]. What matters most: [criteria, e.g. price, features, support].

Do this:
- Build a comparison table scored against my criteria.
- Use current pricing and features — don't rely on memory.
- Recommend one, with a one-line "choose X instead if..." caveat.
- Note anything that changed recently I should know.

Build me a study plan to learn something properly.

I want to learn [topic/skill]. Current level: [beginner / some experience]. I can spend [X hours/week] and want to be [target ability] in [timeframe].

Do this:
- Break it into weekly milestones with a concrete outcome each week.
- For each milestone, give one thing to read/watch and one thing to build or practice.
- Point out where people usually get stuck.
- Tell me how I'll know I've actually learned each part.

Read a paper critically, not just briefly.

My background here is [level].
<paper>
[paste or attach the paper / whitepaper / PDF]
</paper>

Give me:
- The core claim in 2 sentences.
- The method and why it matters, in plain language.
- Key findings with the numbers that back them.
- The stated limitations and anything that seems overclaimed.
- 3 questions I could ask to test the paper's strength.

Test my understanding with active recall.

Quiz me on [topic] at [difficulty]. Base the questions on:
<source>
[paste your notes or the material — or say "general knowledge"]
</source>

Rules:
- Ask one question at a time and wait for my answer.
- After each answer, tell me if I'm right, correct any mistake, and explain briefly.
- Mix recall, application, and one "explain why" question per round.
- After 10 questions, summarize what I know well and what to review.

Stress-test an argument or plan. Think step by step.

<argument>
[paste the claim, plan, or position]
</argument>

Do this:
- First, steelman it: state the strongest version of the case in 4-5 sentences.
- Then critique it: the weakest assumptions, missing evidence, and failure modes.
- Give the single strongest counterargument.
- End with what would change your assessment either way.

Draft a tight one-page business plan.

The business is [what it does] for [target customer], solving [problem]. Model: [how it makes money]. Stage: [idea / early / scaling].

Do this:
- Cover: problem, solution, target customer, revenue model, go-to-market, key risks.
- Keep each section to 2-3 sentences.
- Add 3 assumptions I must validate before investing more.
- Be honest about the weakest part of this plan.

Generate campaign concepts I can actually run.

Product: [product]. Audience: [who]. Goal: [awareness / signups / sales]. Budget vibe: [scrappy / mid / big]. Channels available: [list].

Do this:
- Give 5 distinct concepts, each with a hook, the channel, and the core message.
- For each, name the one metric that would prove it worked.
- Rank them by likely ROI for my budget.
- Flag which are quick to test this week.

Write conversion-focused landing page copy.

Product: [product]. Audience: [who and their main pain]. Primary action: [what they should do]. Proof I have: [testimonials, numbers, logos].

Do this:
- Write a hero headline, subhead, and 3 benefit-led sections (heading + 2 lines each).
- Add a clear CTA and one FAQ that handles the top objection.
- Lead with the customer's outcome, not our features.
- Give me 2 headline variants to test.

Build grounded personas from real inputs.

My product is [product].
<data>
[paste survey responses, reviews, support tickets, or a table of customer data]
</data>

Do this:
- Identify the 2-3 distinct personas actually present in this data.
- For each: goals, pains, objections, and the trigger that makes them buy.
- Quote 1-2 real phrases from the data per persona.
- Note where the sample is too thin to be confident.

Pressure-test my pricing and positioning. Think step by step and use web search for comparables.

Product: [product]. Current price: [price/model]. Positioning line: [how I describe it]. Main competitors: [list].

Do this:
- Tell me who this price signals I'm for, and whether that matches my target.
- Compare against 3 real competitors' pricing and positioning (cite sources).
- Name the biggest risk in my current pricing and one experiment to test it.
- Suggest 2 alternative positioning angles I could own.

Analyze a dataset and tell me what matters. Think step by step.

The question I care about is [question].
<data>
[paste the CSV or attach the spreadsheet; describe the columns]
</data>

Do this:
- Start with a quick data-quality check: row count, missing values, obvious anomalies.
- Answer my question with the specific numbers that support it.
- Show the 3 most important findings, ranked.
- Suggest one chart that would communicate the main finding.

Find the narrative hidden in my data. Think step by step.

Audience for the story: [exec / team / customers].
<data>
[paste the data]
</data>

Do this:
- Surface the 3 most surprising or decision-relevant patterns.
- For each: the finding, the evidence, and the "so what".
- Note any correlation I'd be wrong to read as causation.
- End with the single headline finding, in one sentence.

Clean messy data into something usable.

<raw>
[paste the raw data]
</raw>
I want it as [target format, e.g. a table with columns X, Y, Z].

Do this:
- Normalize inconsistent formats (dates, casing, units, spelling).
- Flag rows that look duplicated or suspect instead of silently dropping them.
- Output the clean version as a table I can paste into a spreadsheet.
- List every transformation you applied so I can audit it.

Turn my data into a clean chart as an Artifact.

<data>
[paste the numbers or a small CSV]
</data>
The point I want the chart to make: [message].

Do this:
- Pick the chart type that best shows that point and say why in one line.
- Render it as an interactive Artifact (single self-contained file).
- Label axes, add a clear title, and format numbers readably.
- Suggest one alternative view of the same data.

Plan a realistic trip itinerary. Use web search for current hours, events, and closures.

Destination: [place]. Dates: [dates]. Travelers: [who]. Budget: [range]. We're into [interests] and want the trip to feel [relaxed / packed].

Do this:
- Give a day-by-day plan grouped by area to minimize travel time.
- Include 1-2 food suggestions per day and a rough daily budget.
- Add a rainy-day backup for each day.
- Flag anything that needs booking ahead.

Help me understand a document before I sign or pay.

I'm worried about [your concern, e.g. hidden fees, cancellation terms].
<document>
[attach or paste the contract / bill / policy / lease]
</document>

Do this:
- Summarize what this commits me to, in plain language.
- List every fee, deadline, and obligation as a bullet.
- Flag anything unusual, one-sided, or worth questioning.
- Give me 3 questions to ask before I agree.
Note that this is general help, not legal advice.

Help me say something hard, well.

I need to [message a friend / decline / apologize / set a boundary] with [who]. The situation: [context]. I want them to feel [respected / clear / cared for].

Constraints:
- Honest, kind, and not passive-aggressive.
- Own my part where fair; don't over-apologize.
- Give me two versions: one softer, one more direct.
- Keep each under 120 words.

Help me build a habit that actually sticks.

The habit I want: [habit]. My motivation: [why]. Past failures: [what's gone wrong]. My daily routine: [rough shape].

Do this:
- Anchor the habit to something I already do (habit stacking).
- Start absurdly small and scale over 4 weeks — give me the weekly targets.
- Design one "if I slip" recovery rule so one miss doesn't end it.
- Suggest a simple way to track it.

Explain a complex thing simply and accurately.

Explain [concept or text] to [audience, e.g. a smart 12-year-old / a busy executive / a new hire].

Constraints:
- Start with a one-sentence plain-English definition.
- Use one concrete analogy and one real-world example.
- Avoid jargon; if a technical term is unavoidable, define it inline.
- Keep it under 200 words.