40+ Best Prompts for Claude Sonnet 5

Claude Sonnet 5 is the model we route 80% of our work through. Not because it's the smartest Claude — Fable 5 holds that title — but because it's the one that makes economic sense to run all day: near-frontier output at a speed and cost that turns "should I ask the AI?" into a non-question. The catch is the same as every model: generic prompts get generic results, and Sonnet 5's speed means you can produce mediocre output faster than ever.

This is our working cheat sheet — 42 prompts across seven categories, every one of them battle-tested, written for copy-paste with [BRACKETED] placeholders. Steal them whole or strip them for parts.

How to Use This Cheat Sheet

Each prompt is a template. Replace anything in [BRACKETS] with your specifics, delete lines that don't apply, and keep the structural bones — the role, the constraints, the output format. Select any prompt block to copy it. They work in the Claude apps, Claude Code, and via API, and most transfer to other frontier models with minor edits (our Gemini cheat sheet follows the same conventions if you run a multi-model stack).

Why Sonnet 5 Specifically

• It's the volume tier. Sonnet 5 is fast and cheap enough to use for every draft, every rewrite, every "quick question" — the workload where Fable 5 would be overkill and the free-tier models would be underpowered.
• It follows structure exceptionally well. Give it an output contract — "return a table with these columns" — and it complies with a consistency older mid-tier models never managed. Every prompt below exploits this.
• It knows when it's guessing. Sonnet 5 flags uncertainty instead of hallucinating confidently, which makes it safe for the research and data prompts in this list.
• It pairs with a heavier closer. The pattern that works: Sonnet 5 for the ten fast iterations, Fable 5 for the final hard pass. Same prompts, escalating model.

On plan economics: Sonnet 5 usage costs a fraction of the flagship on every tier, so heavy Sonnet routing is also how you stay inside Pro limits — see our Claude pricing breakdown for where the ceilings sit.

The Meta-Rules: What Makes These Prompts Work

Seven patterns repeat through all 42 prompts. Learn these and you can write the 43rd yourself:

1. Open with a role and stakes. "You are a senior editor whose reputation depends on..." beats "please edit." Roles activate the right register; stakes activate care.
2. Give a context header. Two lines about your product, audience, or codebase eliminates the generic middle of the answer distribution.
3. Write an output contract. Specify format, length, and structure — "a table with columns X, Y, Z", "exactly 5 options, one line each". Sonnet 5 honors contracts almost perfectly.
4. Ban the failure mode by name. Every model has default bad habits — hedging, filler intros, em-dash abuse, "delve". Prohibit the specific ones that annoy you.
5. Show one example. A single input-output example steers tone better than three paragraphs of description.
6. Make it ask first. For complex tasks, end with "ask me up to 3 clarifying questions before starting" — the cheapest quality upgrade in prompting.
7. Demand ranked output. "Rank by impact" forces prioritization and stops the everything-matters answer.

Coding and Debugging Prompts

Sonnet 5 is a legitimately strong coding model — for deeper agentic work see our Fable 5 Next.js prompts, but for the everyday loop these six cover it.

1. The Bug Root-Cause Hunt

Debug from symptoms without dumping your whole repo.

You are a senior [LANGUAGE/STACK] engineer debugging a production issue.
Symptom: [WHAT HAPPENS — error message, wrong output, timing]
Expected: [WHAT SHOULD HAPPEN]
Code: [PASTE THE RELEVANT FUNCTION(S) ONLY]
Reason about the failure path before proposing anything. List the 3 most likely root causes ranked by probability, the one-line check that would confirm each, and the fix for the top candidate. Do not suggest rewriting the whole module.

2. The Focused Refactor

Improve code without changing what it does.

Refactor this [LANGUAGE] code for readability and maintainability without changing its behavior or public interface.
[PASTE CODE]
Rules: keep the same inputs and outputs, no new dependencies, preserve comments that explain why. Return the refactored code, then a bullet list of what changed and the reasoning, ranked by impact. If the code is already clean, say so instead of inventing changes.

3. The Test Writer

Tests that prove behavior, not coverage theater.

Write [FRAMEWORK — e.g. Vitest / pytest] tests for this function.
[PASTE FUNCTION]
Cover: the happy path, every documented edge case, invalid inputs, and one failure mode I probably have not thought of. Name each test after the behavior it proves, not the function it calls. Mock only external boundaries — never the code under test. Flag any behavior that is untestable as written and say what small change would fix that.

4. The Code Explainer

Understand inherited code fast.

Explain this code to a mid-level developer seeing it for the first time.
[PASTE CODE]
Structure: one-paragraph summary of what it does and why it exists, then a walkthrough of the non-obvious parts only (skip the self-evident lines), then a list of landmines — places where editing carelessly would break something subtle. End with the one question you would ask the original author.

5. The PR Description Writer

Turn a diff into a review-ready description.

Write a pull request description for this diff.
[PASTE DIFF]
Format: a one-line summary a reviewer can approve from, a "What changed" bullet list grouped by area, a "Why" paragraph with the actual motivation, and a "How to test" section with concrete steps. Plain language, no filler, no emoji. If the diff contains anything a reviewer would question, address it preemptively in a "Notes" section.

6. The Error Message Translator

From cryptic stack trace to action in one step.

Here is an error and the context it occurred in:
Error: [PASTE FULL ERROR / STACK TRACE]
Context: [WHAT YOU WERE DOING — command, environment, recent changes]
Tell me: what the error actually means in plain language, the single most likely cause given my context, the fix, and how to verify the fix worked. If multiple causes are plausible, give the 60-second diagnostic that distinguishes them before I change anything.

Writing and Content Prompts

7. The Anti-Generic Draft

First drafts that don't sound like AI wrote them.

Write a [FORMAT — blog post / newsletter / essay] on [TOPIC] for [AUDIENCE].
Voice: [2-3 ADJECTIVES + A WRITER OR PUBLICATION WHOSE STYLE FITS]
Open with the conclusion, not a wind-up. Use concrete numbers and specific examples over abstractions. Short sentences.
Banned: "delve", "in today's fast-paced world", "it's important to note", rhetorical questions as transitions, and any sentence that could appear in an article on a different topic unchanged.
Length: [WORD COUNT]. Ask me 3 clarifying questions before writing.

8. The Ruthless Editor

Cut 30% and make it sharper.

Edit this draft like a ruthless magazine editor. Target: cut length by 30% while making the argument stronger.
[PASTE DRAFT]
Kill: redundant sentences, hedges, throat-clearing intros, and any paragraph that repeats an earlier point. Keep: my voice, my examples, my structure unless a section is genuinely misplaced. Return the edited version, then a short list of the biggest cuts and why. Do not add new content.

9. The Headline Factory

Options across proven angles, not ten synonyms.

Write 10 headline options for this piece: [PASTE INTRO OR SUMMARY].
Use 10 different angles: curiosity gap, specific number, how-to, contrarian, mistake-warning, comparison, outcome promise, question, urgency, and direct statement. Under 60 characters each. Rank your top 3 with one line on why each would win, and flag any that overpromise what the piece delivers.

10. The Tone Shifter

Same content, different room.

Rewrite this text for a different audience without losing any factual content.
Original: [PASTE TEXT]
New audience: [WHO — e.g. executives who have 30 seconds / beginners with no jargon tolerance / a technical review board]
Adjust vocabulary, sentence length, and what gets emphasized first. Keep all facts, numbers, and commitments identical. Return the rewrite, then flag anything that changed meaning even slightly so I can verify.

11. The Outline Architect

Structure before prose — always.

Build an outline for a [LENGTH]-word [FORMAT] on [TOPIC] targeting [AUDIENCE / SEARCH INTENT].
Deliver: a working title, an H2/H3 skeleton with one line per section describing the point it must land, where data or examples are required (marked NEEDS-EVIDENCE), and the one section most writers would include that I should skip. Order sections by reader value, not by chronology.

12. The Repurposing Machine

One asset, five channels.

Repurpose this content into 5 formats:
[PASTE POST OR TRANSCRIPT]
Deliver: a LinkedIn post (hook first line, under 200 words), a tweet thread (5-7 tweets, each standalone-quotable), a newsletter blurb (60 words + CTA), a YouTube description (with timestamps if applicable), and 3 short video hook scripts (15 seconds each). Match each platform's native tone — do not paste the same paragraph five times with different lengths.

Marketing and Growth Prompts

13. The Positioning Sharpener

Find the sentence your product has been missing.

You are a positioning strategist. My product: [WHAT IT IS, WHO IT'S FOR, WHAT IT REPLACES].
Competitors position as: [1-2 LINES ON THE FIELD]
Give me 5 distinct positioning angles. For each: the one-sentence positioning statement, who it wins with, who it loses, and the proof point I would need. Rank by defensibility, not cleverness. Then tell me which one you would bet on and why.

14. The Landing Page Skeleton

Conversion structure with copy to fill.

Write landing page copy for [PRODUCT] targeting [AUDIENCE] with the goal of [CONVERSION ACTION].
Sections: hero headline + subhead (outcome-first, no buzzwords), 3 pain-point blocks written in the customer's own words, how-it-works in 3 steps, social proof placement notes, one objection-handling section for the biggest hesitation ([STATE IT]), and a CTA that names the outcome rather than the action. Provide 2 headline variants per section for testing.

15. The Ad Variant Generator

Testable hooks, not one ad rewritten five times.

Write 8 ad hook variants for [PRODUCT/OFFER] targeting [AUDIENCE] on [PLATFORM].
Each hook: max 12 words, leading with a different psychological trigger — loss aversion, curiosity, social proof, specificity, contrast, urgency, identity, and simplicity. Then write out the full 30-word ad body for your top 2 picks. No exclamation marks, no "game-changer", nothing that sounds like an ad wrote itself.

16. The SEO Content Brief

Briefs that writers can actually execute.

Create an SEO content brief for the target query: [KEYWORD/QUERY].
Include: search intent classification, the title and meta description (under 60/160 chars), an H2 outline that covers the intent completely, 8-10 related questions to answer (People-Also-Ask style), entities and terms that must appear, suggested internal link anchors, and a word-count range justified by what the query needs — not padded. Flag where thin content would be better than long content.

17. The Email Sequence Builder

A sequence with a spine, not five random emails.

Design a [N]-email sequence for [GOAL — onboarding / launch / winback] to [AUDIENCE].
For each email: send-day, subject line + preview text, the single job of the email, a 3-line body skeleton, and the one CTA. The sequence must escalate — each email assumes the previous was seen but not acted on. Vary the angle per email (value, story, proof, objection, deadline). Subject lines under 45 characters, no clickbait that the body can't cash.

18. The Social Proof Miner

Turn raw feedback into usable assets.

Here is raw customer feedback: [PASTE REVIEWS / SURVEY ANSWERS / SUPPORT QUOTES].
Extract: the 5 strongest quotable lines (light edits allowed, marked), the 3 recurring outcomes customers actually value (in their vocabulary, not mine), the objections that appear more than once, and a suggested placement for each quote (landing page section, ad, case study). Ignore praise that is generic enough to be about any product.

Business and Productivity Prompts

19. The Meeting Distiller

From transcript to accountability.

Distill this meeting transcript:
[PASTE TRANSCRIPT]
Output: decisions made (with who decided), action items as a table — owner, task, deadline, blocked-by — open questions that got raised but not resolved, and anything said that contradicts a previous decision I should flag. Max one page. Skip the pleasantries recap entirely.

20. The Hard Email

Say the difficult thing without burning the bridge.

Draft an email where I need to [THE HARD THING — decline, push back, renegotiate, deliver bad news] to [WHO + RELATIONSHIP].
Context: [2-3 LINES OF BACKGROUND]
Constraints: direct in the first two sentences (no burying the point), respectful without groveling, offer one constructive path forward, under 150 words. Give me 2 versions — one warmer, one firmer — and tell me which fits the context better and why.

21. The Decision Memo

Force a recommendation, not a survey.

Write a one-page decision memo on: [THE DECISION TO MAKE].
Context: [CONSTRAINTS, DEADLINE, WHO DECIDES]
Options I am considering: [LIST THEM — or say "generate the options"]
Format: the recommendation in the first line, then the options compared in a table (cost, risk, reversibility, time-to-value), the strongest argument against your recommendation stated honestly, and what evidence would change the answer. No "it depends" endings.

22. The Process Documenter

Turn tribal knowledge into an SOP.

Turn this rough description of how we do [PROCESS] into a clean SOP:
[BRAIN-DUMP THE STEPS, TOOLS, EDGE CASES]
Format: purpose (one line), when to run it, numbered steps with the exact tool/location per step, decision points as if-then lines, common failure points with recovery steps, and who to escalate to. Write it so a new hire could execute it alone on day one. Ask me about any step that is ambiguous instead of guessing.

23. The Prioritization Forcer

When everything feels urgent.

Here is everything on my plate: [LIST TASKS/PROJECTS WITH ROUGH DEADLINES AND STAKES].
My actual goal this [WEEK/MONTH]: [THE GOAL]
Sort everything into: do-first (max 3, with why), schedule (with suggested slots), delegate (with who-shaped description of the right owner), and drop (with the one-line email to kill it gracefully). Challenge me on anything I've mislabeled as urgent that is merely loud.

24. The Stakeholder Update

Status reports people actually read.

Write a stakeholder update on [PROJECT] for [AUDIENCE — exec team / client / board].
Raw status: [BRAIN-DUMP: WHAT SHIPPED, WHAT SLIPPED, WHAT'S BLOCKED, NUMBERS]
Format: overall status in one line (on-track / at-risk / off-track — commit to one), 3 bullets of progress with numbers, risks with mitigation (not just risks), and the single ask I have of the reader. Under 200 words. No adjectives doing the work numbers should do.

Data and Analysis Prompts

25. The Dataset First-Look

What to check before trusting any numbers.

I am about to analyze this dataset: [DESCRIBE COLUMNS + PASTE SAMPLE ROWS].
Question I want to answer: [THE QUESTION]
Before any analysis, list: the data-quality checks to run first (nulls, duplicates, outliers, unit inconsistencies), the columns that could confound the answer, what sample size I would need for the conclusion to hold, and the way this data could mislead me even if it is clean. Then propose the 3-step analysis plan.

26. The Chart Chooser

Right visualization, stated reasoning.

I need to communicate this finding: [THE FINDING + THE DATA SHAPE — e.g. metric over time across 4 segments].
Audience: [WHO SEES IT AND WHERE]
Recommend the single best chart type with reasoning, the title written as the takeaway sentence (not a description), what to label and what to drop, and the one common chart mistake this data invites. If a table beats a chart here, say so.

27. The SQL Writer

Queries with their assumptions on the label.

Write a [DIALECT — Postgres / BigQuery] query to answer: [THE QUESTION].
Schema: [TABLES + RELEVANT COLUMNS + JOINS/KEYS]
Requirements: comment each non-obvious clause, state every assumption you made about the data (timezone, dedup, active-vs-all rows) at the top as comments, and include a companion sanity-check query that validates the result against a number I already trust. Optimize for correctness first, cost second.

28. The Metric Interrogator

Before you report a movement, break it.

Our metric [METRIC] moved [DIRECTION + MAGNITUDE] over [PERIOD].
Context: [ANY LAUNCHES, SEASONALITY, CHANGES YOU KNOW OF]
List every explanation category in order of checking priority: measurement artifacts, mix shifts, seasonality, real behavior change, and external events. For each: the specific check that would confirm or kill it, using data we likely already have. Tell me which explanation is most probable and how confident I should be before presenting this.

29. The Survey Designer

Questions that don't bias their own answers.

Design a survey to learn: [THE DECISION THE SURVEY SHOULD INFORM].
Audience: [WHO + HOW REACHED + REALISTIC LENGTH TOLERANCE]
Deliver: max 8 questions ordered from easy to sensitive, mixing formats deliberately, with every leading question rewritten neutral. For each question: what decision the answer feeds. End with the 2 questions I would be tempted to add that would ruin response rates, so I don't.

30. The Executive Data Summary

Findings, sized for the people who decide.

Summarize this analysis for executives who will spend 90 seconds on it:
[PASTE FINDINGS / NOTEBOOK CONCLUSIONS]
Format: the headline finding as one sentence with the number in it, 3 supporting facts max, what we should do about it (specific, owned, dated), what this does NOT tell us (one honest line), and the appendix pointer. Kill every methodology detail unless omitting it would mislead.

Learning and Research Prompts

31. The Concept Compressor

Understand anything at three depths.

Explain [CONCEPT] at three levels:
1. One paragraph a smart 12-year-old follows.
2. One page for a professional in an adjacent field — analogies allowed, hand-waving not.
3. The practitioner view: what experts argue about, the current consensus, and the common misconception that even intermediate learners hold.
End with the 3 best resources to go deeper, with one line on what each uniquely covers.

32. The Steelman Machine

Test your position against its best opponent.

My position: [STATE IT PLAINLY].
Steelman the opposing view — the strongest version a smart, informed person would actually hold, not the caricature. Then: the 2 points where my position is genuinely weakest, the evidence that would change my mind if it existed, and where the disagreement is really about values rather than facts. Do not soften the attack to be agreeable.

33. The Learning Path Builder

From zero to working competence, sequenced.

Build a learning path for [SKILL] given: my background is [WHAT YOU KNOW], I can spend [HOURS/WEEK], and my goal is [CONCRETE OUTCOME — ship X, pass Y, get hired for Z].
Structure: 4-6 stages, each with the competence it unlocks, the single best resource (not five), a project that proves the stage is done, and the trap that stalls most learners at that stage. Optimize for building things early over completeness.

34. The Paper Distiller

Extract what matters from dense material.

Distill this paper/report for someone who needs its conclusions but not its prose:
[PASTE TEXT OR KEY SECTIONS]
Output: the claim in one sentence, the method in two, the evidence strength (sample, effect size, limitations — be skeptical), what it changes in practice if true, and what the authors' incentives might color. Flag any place where the abstract oversells the results.

35. The Interview Prep Engine

Preparation that targets the actual evaluation.

Prepare me for a [ROLE] interview at [COMPANY/TYPE].
My background: [2-3 LINES]
Deliver: the 8 most likely questions with what each is really testing, a strong answer skeleton for the 3 hardest ones using my actual background, the 2 questions I should ask that signal seniority, and the red-flag answers candidates give without realizing. Then quiz me one question at a time, critiquing each answer before the next.

36. The Research Sprint

Structured desk research with receipts.

Research question: [THE QUESTION].
Decision it informs: [WHY I NEED IT]
Structure your answer as: what is established (with the type of source that backs it), what is contested (both sides, one line each), what is unknown, and your synthesis with a confidence level. Separate facts from your inference explicitly. Where you are unsure, say "unsure" — do not fill gaps with plausible-sounding filler.

Automation and Agent Prompts

37. The Workflow Decomposer

Find what's automatable before automating.

Here is a workflow I do manually: [DESCRIBE THE STEPS, TOOLS, FREQUENCY, TIME COST].
Decompose it: which steps are deterministic (automate with code/rules), which need judgment but follow patterns (delegate to an AI agent with a prompt), and which genuinely need me. For the agent-able steps, write the reusable prompt. For the code-able steps, name the simplest tool. Estimate hours saved per month and the maintenance cost I am signing up for.

38. The Reusable System Prompt

Turn a repeated task into a standing instruction.

I do this task repeatedly: [DESCRIBE TASK + PASTE 1-2 EXAMPLES OF GOOD OUTPUT].
Write a reusable system prompt that would make an AI produce output like my examples every time. Include: role, the quality bar defined by observable properties (not adjectives), format contract, edge-case handling rules, and the banned failure modes you can infer from what my examples deliberately avoid. Keep it under 250 words so it stays maintainable.

39. The Agent Task Brief

Delegation-grade instructions for autonomous runs.

Write a task brief for an AI agent that will work autonomously on: [THE TASK].
Include: the goal with a measurable done-condition, the inputs and where they live, hard constraints (what it must never do), decision rules for the 3 most likely ambiguities it will hit, when to stop and ask versus proceed, and the exact format of the final report. Assume the agent is capable but literal — every unstated assumption becomes a wrong guess.

40. The Prompt Debugger

When output disappoints, fix the input.

This prompt keeps producing disappointing output.
Prompt: [PASTE YOUR PROMPT]
Bad output example: [PASTE WHAT IT PRODUCED]
What I actually wanted: [DESCRIBE OR PASTE AN EXAMPLE]
Diagnose the gap: which instruction is being ignored, which is ambiguous, and what is missing entirely. Rewrite the prompt with the fixes, and annotate each change with the failure it prevents.

41. The Quality Gate

An AI reviewer for AI output.

Act as a quality gate for AI-generated [CONTENT TYPE] before it ships.
Standards: [PASTE YOUR RULES — style guide, banned phrases, factual constraints]
Content to review: [PASTE IT]
Check: rule violations (cite the rule), factual claims that need verification (list them — do not verify by vibes), tone drift from the standard, and structural gaps. Verdict: ship, ship-with-edits (list them), or reject (say why). Be stricter than a polite human reviewer would be.

42. The Escalation Router

Decide which model gets which job.

I run a two-tier model setup: a fast model (Sonnet 5) for volume and a flagship (Fable 5) for hard problems.
My task mix: [LIST YOUR RECURRING TASK TYPES]
For each task type: which tier it belongs on and why, the signal that a specific instance should escalate to the flagship (complexity, stakes, novelty), and the tasks where paying for the flagship is pure waste. Give me the one-line routing rule I can apply without thinking.

Chaining: The Pipelines That Multiply These Prompts

Single prompts save minutes; chains save afternoons. Three sequences we run weekly:

1. The content pipeline: Outline Architect (#11) → Anti-Generic Draft (#7) → Ruthless Editor (#8) → Headline Factory (#9) → Repurposing Machine (#12). One topic in, a week of channel content out.
2. The shipping pipeline: Bug Root-Cause Hunt (#1) → Focused Refactor (#2) → Test Writer (#3) → PR Description (#5). Each stage feeds the previous stage's output in as context.
3. The decision pipeline: Research Sprint (#36) → Steelman Machine (#32) → Decision Memo (#21). Research, stress-test, decide — in an hour instead of a week of meetings.

Run chain stages in fresh conversations when the next stage is evaluative (editing, reviewing, steelmanning) — a model grading its own homework inherits its own blind spots.

Common Mistakes With Sonnet 5

1. Using it like a search engine. One-line questions get one-tier answers. The prompts above are long for a reason — context in, quality out.
2. Never escalating. Sonnet 5 handles 80% of work, but forcing the hardest 20% through it costs more in iterations than Fable 5 costs in usage. Use the Escalation Router (#42).
3. Accepting the first draft. Speed makes it tempting. The second pass — through the Ruthless Editor or Quality Gate — is where output stops being obviously AI.
4. Skipping the output contract. Sonnet 5's superpower is format compliance. A prompt without a format specification wastes the model's best trait.
5. Restating instead of iterating. When output misses, don't re-roll the same prompt — tell it what was wrong. One correction beats three regenerations.

Where to Go From Here

These 42 templates pair with the rest of our prompt library: Fable 5 templates for the heaviest work, the Next.js developer set, the web developer set, and the Gemini 3.5 Flash cheat sheet if you run multiple models. Working from the terminal? Claude Code runs every one of these with your files as context — and if you're picking a plan to run them on, start with our Claude pricing guide.

Keep Building

Browse the full prompt library, compare AI models, or explore more guides on PromptsRush.