A curated library of the best Claude prompts across writing, coding, analysis, business, and research — with the full prompt text in code blocks, what each one does, and exactly why it works. Updated April 2026.
Updated April 26, 2026·~18 min read·Tested on Claude Sonnet 4
1. Why Claude Prompts Are Different
Claude isn't just a different brand of ChatGPT. It has meaningfully different strengths — and prompting it the same way you'd prompt GPT-4o leaves a lot on the table. Three differences define Claude's prompt behavior:
Difference 1
XML Tags
Claude was trained on XML-structured data. Wrapping inputs in <role>, <task>, <context> tags produces more precise, better-organized output than prose descriptions alone.
Difference 2
Long Context
Claude handles 200K+ token inputs without significant degradation. For complex tasks, give Claude the full document — not a summary. It retrieves and synthesizes at scale more reliably than GPT-4o.
Difference 3
Role Depth
Claude internalizes explicit expert role assignments more deeply than most models. "You are a senior M&A attorney with 20 years in cross-border transactions" changes the output meaningfully — not just the tone, but the substance.
Model note: All prompts below are tested on Claude Sonnet 4 (April 2026). Claude's training to be honest and nuanced means it will sometimes push back on vague or over-ambitious requests — these prompts are written to work with that tendency, not fight it.
Feature
ChatGPT prompt approach
Claude prompt approach
Structure
Prose descriptions work
XML tags (<task>, <context>) add precision
Context
Summarize long docs
Paste full docs — Claude handles them
Hedging
"Be direct" reduces hedging
Specify "don't hedge unless genuinely uncertain"
Format defaults
Markdown by default
Prose by default — specify format explicitly
Role
Loose persona works
Specific expertise framing produces measurably better output
2. Prompt Anatomy: The Five Components
Every high-performing Claude prompt is built from up to five components. You don't need all five for every task, but understanding each one — and knowing when to use it — is what separates expert prompting from guesswork.
Component 1
Role
Who Claude is for this task. Specific expertise, experience level, and perspective. The role calibrates vocabulary, analytical depth, and what Claude chooses to include or omit.
<role>You are a CFO at a Series B SaaS company...</role>
Component 2
Task
The specific deliverable. One clear verb + one clear noun. Avoid compound tasks in a single <task> block — break them into separate steps or use numbered subtasks.
<task>Write a 3-paragraph executive summary</task>
Component 3
Context
Everything Claude needs to understand before it begins. Background, input data, audience, and constraints that define the task environment. The most commonly underbuilt component.
The required output structure. Headers, sections, length, bullet vs prose, tone. Claude defaults to prose paragraphs — always specify format explicitly for structured outputs.
<format>H2 sections, max 150 words each, no bullet points</format>
Component 5
Constraints
What Claude must NOT do. The most underused component and often the most valuable. Claude's defaults (balanced framing, diplomatic tone, comprehensive coverage) are sometimes wrong — constraints correct them.
<constraints>Do not hedge. Do not recommend "more research."</constraints>
What a Fully-Built Prompt Looks Like
Here's all five components assembled into a single prompt structure — the template that powers most of the examples in Section 3:
<role>You are a [specific expert] with [specific experience/background].
Your perspective is [key characteristic of the role].</role><task>[One specific verb] [one specific deliverable].</task><context>Audience: [who will read this]
Background: [relevant situation or data]
[Any input material — paste full text here]</context><format>- [Structure requirement 1]
- [Length or section requirement 2]
- [Tone or style requirement 3]</format><constraints>- Do not [default behavior you want to suppress]
- [Specific thing Claude should avoid]</constraints>
The skill gap: Most people who use Claude daily only use 1–2 components. Experts use 3–5 consistently. The difference in output quality is not marginal — it's structural. PromptSharp's daily exercises are specifically designed to build this multi-component fluency through deliberate repetition.
3. The Prompt Library: 25 Best Claude Prompts
Five prompts per category. Each includes the complete prompt text formatted for copy-paste, what the prompt does, and a specific explanation of why it works at the component level.
✍️Writing5 prompts
Long-form article generationContent
<role>You are a senior content strategist who writes long-form editorial content for [industry] publications. Your writing is analytically grounded, uses concrete examples, and avoids generic filler.</role>
<task>Write a 1,200-word article on [topic].</task>
<context>
Target reader: [describe reader — e.g., "mid-level product managers at B2B SaaS companies"]
Primary argument: [your thesis in one sentence]
Key supporting points: [list 3–4 points]
</context>
<format>
- H2 subheadings every 300 words
- Paragraphs max 4 sentences
- End with a concrete takeaway, not a CTA
</format>
<constraints>
- No buzzwords or phrases like "in today's fast-paced world"
- Don't summarize — every paragraph must advance the argument
</constraints>
What it does: Generates a structured, editorial-quality article that reads like a human subject-matter expert wrote it.
Why it works: The "primary argument" field forces Claude to build a thesis-driven piece rather than a listicle. The anti-buzzword constraint counteracts Claude's default tendency toward polished-but-hollow prose. Defining the reader calibrates reading level and what assumptions Claude can make.
Tone rewritingEditing
Rewrite the following text in a [target tone — e.g., "casual, first-person, Slack-message"] tone for [target audience].
Rules:
- Keep all core information intact
- No new information added
- Match the vocabulary level of [audience]
- Max output length: [word count] words
Text to rewrite:
<original>
[Paste text here]
</original>
What it does: Transforms the tone of any text while preserving all factual content.
Why it works: The "no new information" constraint prevents Claude from embellishing. The XML wrapper for the original text signals clearly where the task input ends — preventing Claude from treating instructions as part of the content to be rewritten.
Email sequence (cold or nurture)Copywriting
<role>You are a B2B copywriter specializing in high-conversion email sequences. You write in a direct, conversational style — no corporate buzzwords, no unnecessary soft openers.</role>
<task>Write a [3/5]-email [cold outreach / nurture] sequence for [product/service].</task>
<context>
Target persona: [job title + company type + pain point]
Offer: [what you're offering and why they should care]
Desired action: [CTA — e.g., "book a 20-min call"]
</context>
<format>
For each email:
- Subject line (A and B variant)
- Preheader
- Body (max 150 words)
- CTA (one sentence, no hype)
</format>
<constraints>
- No "I hope this finds you well"
- No "I wanted to reach out"
- Every email opens with a specific insight about the recipient's situation
</constraints>
What it does: Generates a complete, ready-to-send email sequence with subject line variants for each email.
Why it works: The constraint against generic openers directly prevents the most common AI email failure. Subject line A/B variants are built in — saving follow-up requests. The persona definition ensures Claude writes about the right pain point rather than the default "save time / increase revenue" fallback.
Research-backed science communicationExplainer
<role>You are a science communicator who translates academic research for [target audience — e.g., "business executives with no scientific background"].</role>
<task>Summarize the following research paper for this audience.</task>
<context>
<research>
[Paste abstract or full paper here]
</research>
</context>
<format>
Sections:
1. What they studied (2 sentences)
2. What they found (3 sentences, plain language)
3. What this means in practice (2–3 concrete implications)
4. What the study did NOT test or prove (1–2 sentences)
</format>
What it does: Produces a 4-section plain-language research brief targeted at non-specialists.
Why it works: Section 4 ("what they did NOT test") is the credibility builder — it prevents Claude from making a study sound more definitive than it is, which is the most common failure mode in AI-generated research summaries. The structured sections ensure consistent output you can drop into a report.
Argument steelmanAnalysis
I believe the following: [Your position or argument]
Task: Steelman the strongest possible opposing argument. Do not argue against my position — build the best version of the counterargument that a thoughtful, well-informed critic would make.
Requirements:
- Make the counterargument as strong as possible — do not soften it
- Identify the 2–3 core assumptions my position relies on that this counterargument challenges
- End with: "The most important thing this counterargument forces you to address is: [one sentence]"
What it does: Forces a rigorous challenge to your own thinking before committing to a position.
Why it works: "Do not soften it" prevents the diplomatic watering-down Claude does by default when presenting opposing views. The final sentence requirement — the "most important thing" — forces Claude to identify the crux rather than a laundry list of objections. Invaluable for preparing arguments, pitches, and strategic decisions.
💻Coding5 prompts
Code review with actionable outputReview
<role>You are a senior software engineer conducting a code review. You are direct, specific, and prioritize correctness and maintainability over style preferences.</role>
<task>Review the following code and identify issues across these categories.</task>
<context>
Language: [language]
Framework: [framework if applicable]
Purpose: [what this code does]
<code>
[Paste code here]
</code>
</context>
<format>
For each category below, list specific issues with line references. If no issues, write "No issues found."
1. Correctness / Bugs
2. Performance
3. Security
4. Readability
5. Testing gaps
</format>
<constraints>
Do not invent problems. If a category has no issues, say so clearly.
</constraints>
What it does: Produces a structured code review across five specific categories with line-level specificity.
Why it works: "Do not invent problems" is the critical constraint — without it, Claude will find something to say in every category even when the code is clean. Line references make the output immediately actionable. The five-category structure ensures coverage of dimensions that a prose review would conflate.
Debug with root cause analysisDebugging
I have a bug. Here is everything you need to diagnose it.
Language/framework: [language + version]
What I expected: [expected behavior]
What actually happens: [actual behavior, including error messages verbatim]
Steps to reproduce: [numbered steps]
Relevant code:
<code>
[Paste relevant code sections]
</code>
Relevant logs:
<logs>
[Paste logs here, or write "no logs available"]
</logs>
What I've already tried: [list attempted fixes]
Task:
1. Identify the most likely root cause (be specific — not "it might be X")
2. Explain why this cause produces this exact symptom
3. Provide the fix with the exact code changes needed
4. Identify any secondary issues the fix might introduce
What it does: Gets a specific root-cause diagnosis and working fix, not a list of possibilities.
Why it works: "Be specific — not 'it might be X'" eliminates Claude's hedging default. The "what I've already tried" field prevents Claude from suggesting things you've already ruled out. Step 4 (secondary issues) forces Claude to think about the fix holistically, catching regressions before they happen.
Architecture decision with tradeoffsArchitecture
<role>You are a principal software architect who has built production systems at scale. You think in tradeoffs, not best practices.</role>
<task>Help me decide between [Option A] and [Option B] for [specific problem].</task>
<context>
System constraints:
- Scale: [current and projected load]
- Team: [team size and experience level]
- Timeline: [deadline or urgency]
- Budget/infrastructure: [relevant constraints]
- Existing stack: [what you're already running]
The problem I'm solving: [describe the specific problem]
</context>
<format>
1. Recommendation (name one option — be direct)
2. Why: 3 specific reasons this option fits MY constraints
3. Tradeoffs I'm accepting: what Option A gives up vs Option B
4. The one thing that would make you reconsider: [condition]
</format>
What it does: Forces Claude to give a direct recommendation instead of a balanced "it depends" non-answer.
Why it works: "Name one option — be direct" is the key. Claude's default on architecture questions is a thorough both-sides analysis with a non-committal conclusion. The constraints list (team, timeline, scale) ensures the recommendation is specific to your situation. Section 4 (what would make you reconsider) surfaces the actual decision factor without requiring follow-up questions.
API documentation generatorDocumentation
Generate developer documentation for the following [REST API / function / class].
<code>
[Paste code or API definition here]
</code>
For each endpoint/method, document:
1. Description (one sentence — what it does, not how)
2. Parameters: name, type, required/optional, description
3. Returns: type, structure, and what each field means
4. Errors: status codes and what triggers each one
5. Example request + response (realistic values, not "string123")
Additional requirements:
- Write for an engineer who has never seen this codebase
- If any parameter or return value has non-obvious behavior, add a "Note" field
- Use plain JSON for examples, not pseudocode
What it does: Generates complete developer-facing API documentation in one pass.
Why it works: "What it does, not how" prevents implementation leakage in descriptions. "Realistic values, not 'string123'" is the most impactful single constraint — Claude's default example values are useless. The "Note" field for non-obvious behavior ensures the documentation actually teaches the edge cases that cause developer friction.
Refactor with explanationRefactoring
Refactor the following code to improve [readability / performance / testability — pick one].
<code>
[Paste code here]
</code>
Requirements:
- Do not change the external behavior — inputs and outputs must be identical
- Explain each change you make and why it improves [the chosen goal]
- If any change involves a tradeoff (e.g., readability vs performance), say so explicitly
- List any improvements you chose NOT to make and why
Language: [language]
Target: [Python 3.11 / ES2022 / etc]
What it does: Refactors code for a specific quality goal while preserving behavior, with full explanation of every change.
Why it works: "Explain each change and why" transforms Claude's output from a black-box code swap into a teaching document. "List improvements you chose NOT to make" is the most valuable constraint — it surfaces Claude's reasoning about what it deprioritized, which often reveals important tradeoffs you'd want to know about before merging.
📊Analysis5 prompts
Data interpretation briefData
<role>You are a data analyst with expertise in [domain]. You communicate findings to business stakeholders who are not technical.</role>
<task>Analyze the following data and produce an executive brief.</task>
<context>
Business question: [What decision does this data inform?]
Audience: [Who will read this brief?]
<data>
[Paste data here — CSV, table, or raw numbers]
</data>
</context>
<format>
1. Key finding (one sentence — the most important thing the data shows)
2. Supporting evidence (3 specific data points that support the finding)
3. What the data does NOT tell us (2 limitations the audience must understand)
4. Recommended action based on this data
5. What additional data would change the recommendation
</format>
<constraints>
- Do not soften or spin negative findings
- Do not use statistical jargon without plain-language translation
- Confidence level: state how confident you are in the key finding (high / medium / low) and why
</constraints>
What it does: Transforms raw data into a structured executive brief with explicit limitations and confidence level.
Why it works: Section 3 ("what the data does NOT tell us") is the most valuable output and the section most analysts — human and AI — skip. "Do not soften negative findings" prevents the diplomatic framing that makes bad results look better than they are. The confidence level requirement prevents overconfident interpretation.
Competitive analysis frameworkStrategy
<role>You are a competitive intelligence analyst with experience in [industry]. You identify sustainable advantages, not surface-level feature comparisons.</role>
<task>Analyze the competitive position of [Company A] vs [Company B] and [Company C].</task>
<context>
Product/market: [describe what these companies sell and to whom]
My company's position: [Company A — who you are and what you sell]
Known information about competitors:
<competitors>
[Paste any known info: pricing pages, reviews, LinkedIn posts, press releases]
</competitors>
</context>
<format>
For each competitor:
- Core value proposition (one sentence from THEIR perspective, not yours)
- Likely customer profile (who buys from them and why)
- Structural advantage (what they have that's hard to replicate)
- Structural weakness (where they're systematically vulnerable)
Then: Where do you have a genuine differentiation window? (Be specific — not "better quality")
</format>
What it does: Produces a differentiation-focused competitive analysis that identifies actual strategic windows, not a feature checklist.
Why it works: "From THEIR perspective, not yours" forces Claude to model the competitor's own positioning logic — preventing the common failure of analyzing competitors through your product's lens. "Structural advantage/weakness" filters for durable advantages vs. temporary ones. The final question ("not 'better quality'") forces specificity.
Financial summary with red flagsFinance
<role>You are a CFO advisor who reviews financial statements for early-stage companies. You identify both strengths and early warning signs before they become problems.</role>
<task>Review the following financial data and produce a health summary.</task>
<context>
Company stage: [pre-revenue / seed / Series A / etc.]
Period: [Q or FY and year]
<financials>
[Paste P&L, balance sheet, or cash flow data here]
</financials>
</context>
<format>
1. 30-second summary (2 sentences — what's the overall picture?)
2. Top 3 strengths (specific, with supporting numbers)
3. Top 3 concerns (specific, with supporting numbers)
4. The one metric that most needs to improve in the next 90 days
5. Questions a board member would ask (list 3)
</format>
<constraints>
- Do not spin negative results positively
- State what the data does NOT cover (e.g., "No cash flow data provided — cannot assess runway")
</constraints>
What it does: Produces a board-ready financial health brief with specific numbers, concerns, and anticipatory questions.
Why it works: "Do not spin negative results positively" is essential for financial prompts — Claude defaults to balanced, diplomatic framing that can obscure real problems. Section 5 (board questions) produces forward-looking value by anticipating the challenge before the meeting. The data gap declaration prevents false confidence from incomplete inputs.
Decision analysis with second-order effectsDecision-making
I need to decide whether to [do X or not / choose between X and Y].
Decision context:
- What's at stake: [what changes depending on the decision]
- Timeline: [how long do I have, and when is this reversible vs. irreversible]
- Key constraints: [resources, people, other commitments affected]
- My current lean: [what I'm inclined toward and why]
Task:
1. Identify the 3 most important factors in this decision
2. For each factor, tell me which option it favors and why
3. What second-order effects am I probably not considering?
4. What would you need to know that I haven't told you?
5. Recommendation: what would you do if this were your decision?
<constraints>
Be direct. Do not say "it depends" without specifying on what.
</constraints>
What it does: Produces a structured decision brief that surfaces factors, second-order effects, and a direct recommendation.
Why it works: Step 3 (second-order effects) is where Claude adds the most value — it can see systemic effects that you're too close to your own situation to see. "What would you do if this were your decision?" forces Claude out of advisor mode into a direct position. The constraint against "it depends" without specificity is critical for actual decision support.
Survey/interview synthesisResearch synthesis
<role>You are a qualitative research analyst. You identify patterns across responses and distinguish genuine signal from noise.</role>
<task>Synthesize the following [customer interviews / survey responses / user feedback] into a findings brief.</task>
<context>
Research question: [what were you trying to learn?]
Number of responses: [N]
Method: [interview / survey / open text / etc.]
<responses>
[Paste responses here]
</responses>
</context>
<format>
1. Top 3 themes (with frequency: how many responses reflect this?)
2. Most surprising finding (what you didn't expect, and what it implies)
3. Representative quotes (2–3 verbatim quotes per theme)
4. What the data cannot tell you from this sample alone
5. Recommended follow-up question for next round
</format>
What it does: Transforms raw qualitative data into a structured research brief with themes, frequency, and representative quotes.
Why it works: Frequency labeling ("how many responses reflect this?") forces Claude to distinguish majority themes from one-off anecdotes, which unstructured synthesis almost never does. "Most surprising finding" is the highest-value section for product and business insight. The follow-up question closes the research loop.
💼Business5 prompts
Job description with anti-bias languageRecruiting
<role>You are a talent acquisition specialist who writes job descriptions that attract qualified candidates while reducing common screening biases.</role>
<task>Write a job description for a [role title] at a [company stage] company.</task>
<context>
Team: [team name and size]
Reports to: [title]
Key outcomes the person must deliver in 90 days: [list 2–3]
Must-have qualifications: [hard requirements — be minimal, not a wishlist]
Nice-to-have: [genuinely optional]
Salary range: [if sharing]
Work arrangement: [remote / hybrid / in-person + location]
</context>
<format>
- About the role (2 sentences — the exciting part)
- What you'll do (outcomes, not tasks — use "You will achieve X" not "Responsibilities include X")
- What we need (must-haves only — max 5)
- What's nice to have (clearly labeled optional)
- What we offer
</format>
<constraints>
- No "rockstar," "ninja," "passionate about," or "fast-paced environment"
- Years of experience not as a requirement — only if truly essential
- No degree requirement unless legally required for the role
</constraints>
What it does: Generates an outcomes-focused job description with reduced bias language and a realistic requirements list.
Why it works: Framing outcomes instead of tasks ("You will achieve" vs "Responsibilities include") is research-backed to attract senior candidates who think in deliverables. The anti-bias constraints in the constraint block directly counteract the most common JD language problems that filter out qualified candidates.
Executive update memoCommunication
Write an executive update memo for [project/initiative].
Audience: [executive/board — their background and what they care about]
Format: Email memo, max 300 words
Structure the memo as follows:
1. Status: [On Track / At Risk / Off Track] — one sentence why
2. What happened this period (2–3 bullets — outcomes, not activities)
3. What's happening next period (2–3 bullets with owners and dates)
4. One decision or resource needed from this audience (be specific)
5. Any risks to flag (or "No risks at this time")
Context for the memo:
<context>
Project: [project name and goal in one sentence]
Period: [e.g., "Week of April 21"]
Key developments: [list what happened — raw notes okay]
</context>
Tone: Direct, factual, no corporate filler. Write for someone who has 90 seconds.
What it does: Transforms raw project notes into a structured executive memo that reads in under 2 minutes.
Why it works: "Outcomes, not activities" is the most important instruction — executives don't need to know you had meetings, only what those meetings produced. Section 4 (one decision needed) ensures every executive update has a clear ask, which is what makes the communication useful rather than informational. The 90-second tone calibration is explicit and effective.
Meeting agenda and pre-readMeetings
Create a meeting agenda and optional pre-read for the following meeting.
Meeting purpose: [one sentence — what decision or output should this meeting produce?]
Attendees: [list roles — not names — and their relationship to the topic]
Duration: [time]
Format: [in-person / video call / async]
Agenda items I know I need to cover:
- [Item 1]
- [Item 2]
- [Item 3]
Background context:
<context>
[Paste relevant context, documents, or prior decision history]
</context>
Produce:
1. Agenda with time allocations (ruthlessly realistic — leave buffer)
2. The one pre-read document each attendee must read before arriving
3. Three specific questions to send to attendees beforehand to make the meeting faster
4. Decision log template to fill in during the meeting
What it does: Generates a complete meeting package — agenda, pre-read requirements, pre-work questions, and decision log — from a rough outline.
Why it works: "Ruthlessly realistic — leave buffer" prevents the agenda that looks good on paper but always runs over. The three pre-work questions are the highest-leverage output — they shift cognitive work out of the meeting itself. The decision log template ensures the meeting produces a written artifact, not just discussion.
Pricing strategy analysisStrategy
<role>You are a pricing strategist who has worked with B2B and B2C software companies. You think about pricing as a strategic lever, not just a revenue mechanism.</role>
<task>Analyze our current pricing and recommend changes.</task>
<context>
Product: [describe what you sell and to whom]
Current pricing: [describe your pricing model, tiers, and price points]
Customer profile: [who buys, what they value, what alternatives they consider]
Competitive pricing: [what do competitors charge?]
Current conversion rate / churn rate: [if known]
Business goal: [increase new customer acquisition / reduce churn / move upmarket / etc.]
</context>
<format>
1. Diagnosis: What does current pricing signal to buyers? (How does it position you relative to alternatives?)
2. Three pricing changes to consider (specific — not "increase prices")
3. The change I'd test first and why (name one)
4. What a price change would break (who would you lose?)
5. Metric to track for 90 days post-change
</format>
What it does: Produces a structured pricing audit with specific recommendations and risk assessment.
Why it works: Section 1 (what does pricing signal?) is the most valuable insight — pricing is as much a communication tool as a revenue tool, and most founders don't think about what their price point implies to buyers. The "what would break" section surfaces the real cost of changes before you make them. "Name one" prevents the non-committal multi-option response.
Investor update letterFundraising
<role>You are a founder advisor who has helped 50+ companies communicate with investors. You write clearly, numerically, and without hype.</role>
<task>Write a [monthly / quarterly] investor update for [company name].</task>
<context>
Company: [one-sentence description]
Period: [month/quarter]
Metrics this period: [ARR, MRR, growth rate, burn, runway — paste raw numbers]
Key wins: [what went well]
Key challenges: [what's not working — be honest]
What you need from investors: [intros, advice, candidates — be specific]
</context>
<format>
- Opening: one-sentence summary of the period (good AND bad)
- Metrics snapshot (table format, with vs. prior period)
- Highlights (3 bullets — outcomes, not activities)
- Challenges and what you're doing about them (2 bullets — honest, not defensive)
- The ask (specific, actionable)
- Next period focus (2 bullets)
</format>
<constraints>
- No vanity metrics
- If a metric declined, say so and explain why
- No "we're excited to share" or "proud to announce" — get to the numbers
</constraints>
What it does: Generates a credibility-building investor update that's honest about challenges while maintaining investor confidence.
Why it works: The "challenges and what you're doing about them" section is where most investor updates fail — founders either omit challenges or present them defensively. "Honest, not defensive" is a specific tone instruction Claude responds to. The constraint against vanity metrics forces the update to lead with business-relevant numbers that investors actually want to see.
🔬Research5 prompts
Literature review synthesisAcademic
<role>You are an academic researcher in [field]. You synthesize literature into coherent narratives, not lists of summaries.</role>
<task>Synthesize the following papers into a literature review section on [topic].</task>
<context>
<papers>
[Paste abstracts or full text of papers — number them 1, 2, 3...]
</papers>
My research question: [what are you trying to understand or argue?]
Target length: [word count]
</context>
<format>
Produce a literature review section that:
- Opens with the state of knowledge on [topic]
- Groups papers by theme, not chronologically
- Identifies where papers agree and where they contradict each other
- Ends with the gap your research addresses
Citations: use [Author, Year] inline format
</format>
<constraints>
- Do not summarize each paper independently — synthesize across them
- Do not introduce papers you haven't been given
- Identify explicitly where evidence is weak or contested
</constraints>
What it does: Synthesizes multiple research papers into a coherent literature review section that groups by theme and identifies gaps.
Why it works: "Do not summarize each paper independently — synthesize across them" is the critical constraint. Without it, Claude produces a list of paper summaries (easy but wrong). "Do not introduce papers you haven't been given" prevents Claude from hallucinating citations — a known failure mode in research contexts.
Market sizing estimationMarket research
<role>You are a market research analyst who has built TAM/SAM/SOM models for venture-backed companies. You reason from first principles and are explicit about assumptions.</role>
<task>Estimate the market size for [product or service category].</task>
<context>
Product: [describe what you sell]
Geography: [US / global / specific region]
Customer type: [B2B or B2C, and who specifically]
Known data points: [any research, benchmarks, or comparables you have]
</context>
<format>
1. Top-down estimate: [industry size] × [relevant % we could address] = [SAM]
2. Bottom-up estimate: [number of potential customers] × [average contract value] = [SAM from below]
3. Reconciliation: why the two estimates do or don't align
4. My best estimate of SAM (single number — not a range)
5. The two assumptions this estimate is most sensitive to
</format>
<constraints>
- State every assumption explicitly
- Do not present a range as your answer — pick a number and defend it
- Flag if any required data point is missing
</constraints>
What it does: Generates a dual-method market size estimate with explicit assumptions and sensitivity analysis.
Why it works: The two-method approach (top-down + bottom-up) with a reconciliation step forces internal consistency — a single-method estimate is easy to sandbag or inflate. "Do not present a range as your answer" forces a commitment that investors and operators can actually use. Section 5 (sensitivity assumptions) tells you exactly where to focus your market research effort.
Industry trend analysisIntelligence
<role>You are an industry analyst covering [sector]. You distinguish durable trends from hype cycles and focus on structural shifts with multi-year implications.</role>
<task>Analyze the major trends in [industry] as of [year] and their implications.</task>
<context>
My interest: [what business or investment decision does this inform?]
Time horizon: [1 year / 3 years / 5 years]
Known context: [paste any relevant articles, reports, or data you have]
</context>
<format>
1. Three structural trends (changes in underlying economics, regulation, technology, or behavior — not "AI is growing")
2. For each trend: who wins, who loses, and the timeline
3. The trend most people are underweighting
4. What you'd watch as early indicators that any of these trends are accelerating or reversing
</format>
<constraints>
- No generic statements like "digital transformation is continuing"
- Cite specific mechanisms, not just directions
- Distinguish between trends that are cyclical vs. structural
</constraints>
What it does: Produces a specific, mechanism-based trend analysis with winners/losers and leading indicators.
Why it works: "Not 'AI is growing'" is the key constraint — it forces Claude to identify the specific second-order effects of broad trends rather than restating the headline. "Cite specific mechanisms, not just directions" is what separates useful trend analysis from generic forecasting. The "underweighting" section often produces the most non-obvious insight.
Expert interview question generatorInterviews
Generate interview questions for a conversation with [expert's role/title] about [topic].
My goal for this conversation: [what do I want to learn that I can't get from public sources?]
What I already know: [your current knowledge level — prevents Claude from generating obvious questions]
Interview context: [podcast / research / due diligence / journalism / etc.]
Duration: [30 / 45 / 60 minutes]
Generate:
1. Three opening questions (build rapport and establish their frame)
2. Five core questions (the substance of what you want to learn)
3. Three follow-up probes for each core question (what to ask if they give a surface answer)
4. One closing question that often gets the best response: the thing most people don't think to ask
<constraints>
- No yes/no questions
- No questions that can be answered by their LinkedIn or company website
- At least one question that assumes things might not be going as well as they appear publicly
</constraints>
What it does: Generates a full interview structure with follow-up probes built into the question set.
Why it works: "What I already know" prevents Claude from generating the obvious beginner questions. The follow-up probes for each core question are the highest-value output — they're what transforms an interview from a monologue into a dialogue. The constraint about "things might not be going as well as they appear publicly" generates the questions that produce genuinely novel insight from experts who give polished answers by default.
Hypothesis-driven research planPlanning
<role>You are a research lead who designs studies to answer business questions efficiently. You think in hypotheses, not in topics.</role>
<task>Create a research plan to answer: [research question]</task>
<context>
Business decision this informs: [what will you do differently based on the findings?]
Resources available: [time, budget, access to participants/data]
Current belief: [what do you think the answer is, and how confident are you?]
</context>
<format>
1. Primary hypothesis (falsifiable statement — not a question)
2. How we'd know if the hypothesis is true (specific measurable criteria)
3. How we'd know if the hypothesis is false
4. Research method and why it's appropriate for this hypothesis
5. Sample/data requirements (minimum for a valid result)
6. Timeline: fastest viable version vs. comprehensive version
7. Pre-mortem: what would make these findings useless?
</format>
What it does: Converts a research question into a falsifiable hypothesis with a minimum-viable research design and explicit validity conditions.
Why it works: The "falsifiable statement" requirement is the core insight — most research plans fail because they're designed to confirm a belief rather than test one. Sections 2 and 3 (how you'd know if it's true AND false) force pre-definition of success and failure before data collection begins. The pre-mortem question surfaces methodological weaknesses while there's still time to address them.
4. Five Principles for Better Claude Prompts
The patterns in the prompts above can be distilled into five principles that apply to every prompt you write for Claude:
1
Specify what NOT to do, not just what to do
Claude has strong defaults. Many of them are wrong for specific tasks — diplomatic framing, hedging, comprehensive lists when you want a single recommendation. Constraints ("do not hedge," "do not summarize each paper separately") are often more impactful than instructions. Think of constraints as Claude's "anti-defaults."
2
Force one answer, not a list of options
Claude's safest output is always a balanced both-sides presentation. This is useless when you need a decision or recommendation. Add "name one option — be direct" or "recommend one — not a list" to any prompt where you want a verdict rather than a survey of possibilities.
3
Use XML tags for complex structured inputs
Whenever your prompt contains a mix of instructions and content (a document to summarize, code to review, data to analyze), wrap the content in XML tags. This makes the structural boundary unambiguous and produces more consistent output, especially with long contexts.
4
Build in the uncomfortable question
Claude will answer the question you ask. It will rarely volunteer the uncomfortable angle — the limitation, the risk, the second-order effect. Build it in explicitly: "what could go wrong," "what the data does NOT tell us," "what question am I not asking." This is where Claude generates its most non-obvious and valuable outputs.
5
State your current belief before asking for analysis
Telling Claude what you currently think — even incorrectly — produces better analysis than starting from a blank slate. "My current belief is X — what's wrong with this thinking?" generates more specific, contrarian, and useful responses than "tell me about X." It forces Claude to engage with your actual mental model, not a generic overview.
5. Frequently Asked Questions
Claude was trained on XML-structured data and responds especially well to XML tags like <role>, <task>, <context>, and <format>. Claude also handles 200K+ token contexts without significant degradation, handles pushback on ambiguous requests better, and responds to explicit expert role assignments more deeply. ChatGPT tends to perform better with more conversational prose prompts; Claude performs better with structured, XML-organized prompts.
Not every prompt needs XML tags — a simple question can be asked in plain prose. But for any multi-part prompt, complex task, or prompt where you're providing structured inputs (documents, data, code), XML tags dramatically improve Claude's output quality and consistency. Think of them as section headers that Claude reads before it begins generating, not arbitrary formatting.
Claude Sonnet 4 handles the vast majority of tasks in this guide — writing, code review, business analysis, research synthesis. Reserve Claude Opus for multi-step reasoning tasks where you need the highest possible quality and can accept slower generation. All prompts in this guide were tested on Claude Sonnet 4 as of April 2026.
These prompts took significant iteration to develop. The fastest path to this skill level is deliberate daily practice on specific techniques: XML structuring, few-shot calibration, chain-of-thought decomposition, constraint discipline. PromptSharp teaches these through daily 5-minute exercises with Claude-graded feedback — the same Duolingo-style repetition loop that builds lasting skill, not passive consumption of guides like this one.
Yes — all prompts on this page are free to use for personal and commercial work. The output Claude generates using your prompts belongs to you, subject to Anthropic's usage policies. For commercial use cases requiring consistent, high-quality prompt outputs across a team, consider PromptSharp's team plan at $59/month.
Every high-performing Claude prompt is built from up to five components: Role (who Claude is), Task (what Claude must do), Context (background and input data), Format (required output structure), and Constraints (what Claude must NOT do). Most beginners use 1–2 components. Experts consistently use 3–5. The gap in output quality between these levels is not marginal — it's structural. Section 2 of this guide covers each component in detail with examples.
Reading good prompts teaches you patterns. Writing prompts — with feedback — builds the skill. PromptSharp gives you a daily Claude-graded exercise that trains your prompt instincts the same way Duolingo trains language: through deliberate, repetitive practice.