50 Claude Sonnet 4.6 Prompts That Actually Work (Copy-Paste Library, 2026)

Claude Sonnet 4.6 (model ID: claude-sonnet-4-6) is not a generic chat assistant — it is an instruction-following engine with a 200K token context window, extended thinking mode, and a 79.6% SWE-bench Verified score. The prompts that work with it are specific and structured. Generic prompts produce generic output.

These are prompts I use weekly across writing, coding, analysis, SEO, and business operations. The output snippets are real. The “why it works” notes reflect actual failure modes discovered when a prompt version didn’t work — not abstract advice.

If you’re evaluating Claude against GPT-4o for specific workflows, the task-by-task comparison in Claude Sonnet 4.6 vs GPT-4o: 5 Real Business Tasks, Honest Verdict shows where the prompt structure differences show up in output quality.

How to Use This Library

Copy the prompt, paste it into Claude.ai or your API implementation, and swap the [BRACKET] placeholders. System prompt templates (marked System:) go in the system field; user prompts go in the human turn.

For API users: append "thinking": {"type": "enabled", "budget_tokens": 5000} to your request body for extended thinking prompts. For Claude.ai users: toggle the “Extended thinking” option in the model settings.

Section 1: Writing Prompts (10 Prompts)

1. Long-Form Article Draft from Outline [Standard]

<instructions>
You are a senior technology journalist. Write in Bloomberg style: BLUF first, no hype,
no filler phrases. Each H2 must be answered in its first sentence. No passive voice.
Banned words: revolutionary, game-changing, seamless, robust, leverage.
Target audience: working professionals who use AI tools in their workflows.
</instructions>

Write a [WORD_COUNT]-word article from this outline:
[PASTE_OUTLINE]

Section word targets: [H2_1]: [N] words, [H2_2]: [N] words...
Include one comparison table where indicated.

Why it works: The XML wrapper locks the style constraints across 4,000+ word drafts. Without it, Claude defaults to its baseline voice by section 3. The banned-words list prevents the 8 most common AI-writing tells.

2. Rewrite Any Draft to Bloomberg Style [Standard]

Rewrite this draft in Bloomberg terminal style. Rules:
- Move the bottom line to sentence 1
- Cut every paragraph that is scene-setting without data
- Replace every "is expected to" with a direct claim or cut it
- Every H2 must answer its own question in the first sentence
- Target: [TARGET_WORD_COUNT] words (current: [CURRENT_WORD_COUNT])

Draft:
[PASTE_DRAFT]

Why it works: The explicit cut instructions give Claude a task, not just a style note. “Bloomberg style” alone produces ~60% accurate rewrites; the rule list produces ~90%.

3. Email Sequence (5-Part Nurture) [Standard]

Write a 5-email nurture sequence for [PRODUCT/SERVICE].

Audience: [DESCRIBE_AUDIENCE]
Goal: Convert trial users to paid plans
Sequence timing: Day 0, Day 2, Day 5, Day 10, Day 21

For each email:
- Subject line (under 50 characters, no emojis)
- Preview text (under 90 characters)
- Body (150-200 words, one CTA, plain text only)
- CTA button text

Tone: direct, peer-to-peer, no corporate language.

Why it works: The per-email character limits force Claude into production-ready output without a second editing pass. Without them, it writes 400-word emails that need heavy cutting.

4. Technical Explainer (Expert-to-Novice Translation) [Standard]

Explain [TECHNICAL_CONCEPT] to a smart non-technical professional.

They know: [WHAT_THEY_ALREADY_UNDERSTAND]
They do not know: [TECHNICAL_PREREQUISITES_TO_AVOID]
Their goal: [WHAT_THEY_WANT_TO_DO_WITH_THIS_KNOWLEDGE]

Use one real-world analogy. Include one "what breaks if you get this wrong" example.
Target: 400 words, no jargon, no acronyms without definition.

Why it works: The “they do not know” constraint prevents Claude from explaining the thing using sub-concepts the audience also doesn’t know — the most common failure mode in Claude’s technical explainers.

5. Competitor Comparison Table [Standard]

Build a comparison table for these products: [PRODUCT_1], [PRODUCT_2], [PRODUCT_3]

Compare on these dimensions only: [DIM_1], [DIM_2], [DIM_3], [DIM_4], [DIM_5]

Data format: use exact figures where publicly documented. Mark estimated figures with (~).
Mark unavailable data with "N/A" — do not infer.
Output: Markdown table, then one paragraph per product summarizing their ideal use case.
Source all pricing claims from the official pricing page as of [DATE].

Why it works: The “mark estimated figures with (~)” instruction forces Claude to signal uncertainty rather than silently infer — critical when the table will be published.

6. Content Brief from Target Keyword [Extended Thinking]

Create a content brief for the target keyword: "[TARGET_KEYWORD]"

Research context: [PASTE_SERP_NOTES_OR_COMPETITOR_URLS]

Brief must include:
1. BLUF title (under 65 characters)
2. Target word count with section breakdown
3. 5 H2s that directly answer search intent questions
4. One data table the article should include
5. 3 named competing posts we must beat and why our angle differs
6. Non-commodity score estimate (0-5 markers): named entities, first-hand angle, quantified data, benchmarks, operator pain

Why it works: Extended thinking lets Claude reason through the search intent before proposing the structure — the resulting brief has tighter angle differentiation than a standard-mode brief on the same keyword.

7. Op-Ed Draft from a Strong Opinion [Standard]

Write an op-ed from this position: "[YOUR_STRONG_OPINION]"

Audience: [TARGET_PUBLICATION] readers (working professionals, not academics)
Length: 700 words
Format: 4 paragraphs — claim, evidence, objection steelman, call to action
Tone: confident, not aggressive. Direct, not preachy.
Do not soften the main claim. Do not add "of course, there are other views."

Why it works: The “do not soften” instruction is essential. Without it, Claude hedges the main argument in the conclusion — producing a balanced article where you wanted a pointed one.

8. Case Study from Raw Notes [Standard]

Write a B2B case study from these raw notes. Format:
- Client: [COMPANY_NAME] ([INDUSTRY], [SIZE])
- Challenge: [PROBLEM_IN_2_SENTENCES]
- Solution: [WHAT_WAS_BUILT_OR_DEPLOYED]
- Results: [METRICS_AND_TIMEFRAME]

Structure: Problem → Approach → Result → Lesson
Length: 600 words
Voice: third-person, past tense, specific numbers only
Include one pull quote formatted as a blockquote (attribute to role, not name if no permission)

9. LinkedIn Post from Long-Form Article [Standard]

Distill this article into a LinkedIn post.

Article: [PASTE_ARTICLE_OR_KEY_POINTS]

Rules:
- First line must be the single most surprising or counterintuitive finding
- No hashtags in the body (add 3 at the end only)
- 200-250 words
- End with a question that provokes comments, not a CTA to click the article
- No bullet points — paragraph format only

10. Newsletter Introduction from Article Draft [Standard]

Write a newsletter introduction for this week's edition. The main article is about: [TOPIC]

Tone: editor writing to intelligent subscribers, not a marketing email
Length: 120-150 words
Structure: 1 observation about why this topic matters THIS week → 1 sentence teaser for the main piece → 1-line transition into the content
Do not start with "This week" or "In this issue."

Section 2: Coding Prompts (10 Prompts)

Claude Sonnet 4.6’s 79.6% SWE-bench Verified score reflects real performance on autonomous coding tasks — not just code completion. These prompts are structured for Claude Code (CLI) and API-based code generation, targeting the patterns that produce working, reviewable code rather than plausible-looking but broken outputs.

11. Code Review with Failure Mode Identification [Extended Thinking]

Review this code for correctness bugs and simplification opportunities.

<code>
[PASTE_CODE]
</code>

Focus areas (in priority order):
1. Logic errors that would fail silently in production
2. Edge cases not handled (empty input, None, type mismatches)
3. Security issues (injection, exposed secrets, unvalidated input)
4. Simplifications using stdlib (no new dependencies)

Output format: each finding as "File:Line — Issue — Fix" with a one-line code snippet.
Skip style issues (formatting, naming) unless they obscure logic.

Why it works: The priority order prevents Claude from leading with style nitpicks when there are correctness bugs. Extended thinking surfaces failure modes a surface reading misses.

12. Write a Function with Edge Cases and Test [Standard]

Write a [LANGUAGE] function that [DESCRIBE_WHAT_IT_DOES].

Constraints:
- Input: [INPUT_TYPE_AND_SHAPE]
- Output: [OUTPUT_TYPE_AND_SHAPE]
- Edge cases to handle: [LIST_EDGE_CASES]
- Must not use: [BANNED_LIBRARIES_OR_PATTERNS]
- Performance target: [O(N) or specific requirement if relevant]

After the function, write one runnable self-test using assert statements only.
No test frameworks. The test should fail if the function's core logic breaks.

13. Refactor for Readability (No Behavior Change) [Standard]

Refactor this code for readability. Hard rules:
- Zero behavior change. The output of every function must be identical.
- No new dependencies
- No new abstractions unless 3+ callers exist
- Do not add error handling that wasn't there before

Show the diff only — not the full file. Explain each change in one line.

Why it works: The “zero behavior change” rule prevents Claude from “improving” logic while refactoring — a common failure mode that introduces silent bugs during cleanup passes.

14. Debug a Failing Test [Extended Thinking]

This test is failing. Find the root cause — not just why the assertion fails,
but what the actual bug is in the implementation.

Test:
[PASTE_FAILING_TEST]

Implementation:
[PASTE_RELEVANT_IMPLEMENTATION]

Error output:
[PASTE_ERROR]

Output: root cause in one sentence → minimal fix → confirm the fix passes the test.
Do not add extra error handling unless the fix requires it.

15. Generate API Client from Documentation [Standard]

Write a minimal [LANGUAGE] client for this API.

Endpoint documentation:
[PASTE_API_DOCS_OR_OPENAPI_SNIPPET]

Requirements:
- Auth method: [API_KEY / OAUTH / BEARER]
- Methods needed: [LIST_ENDPOINTS]
- Error handling: raise on 4xx/5xx with the response body in the exception message
- No SDK dependencies — stdlib HTTP only

Include a usage example at the bottom as a comment.

16. Write SQL for a Complex Query [Standard]

Write a SQL query for [DATABASE: PostgreSQL/MySQL/BigQuery] that:
[DESCRIBE_WHAT_THE_QUERY_MUST_RETURN]

Schema:
[PASTE_RELEVANT_TABLE_DEFINITIONS]

Performance note: [TABLE_SIZE — e.g. "orders table has 50M rows, indexed on user_id and created_at"]
Output: query + one-line explanation of the join strategy + any index recommendation.

17. Convert Script to Async [Standard]

Convert this synchronous [LANGUAGE] script to async.

[PASTE_SCRIPT]

Rules:
- Preserve all existing error handling
- Use asyncio (Python) / async-await (JS/TS) — no third-party concurrency libraries
- Add concurrent execution only where the original code does sequential I/O waits
- Do not parallelize CPU-bound sections

Annotate each change with a one-line comment explaining why it was made async.

18. Write a Dockerfile for Production [Standard]

Write a production Dockerfile for this application.

Runtime: [PYTHON 3.12 / NODE 20 / etc.]
App entrypoint: [e.g. "python -m uvicorn app.main:app --host 0.0.0.0 --port 8080"]
Dependencies file: [requirements.txt / package.json / etc.]
Sensitive env vars: [LIST_VAR_NAMES — do not bake them in]

Requirements:
- Multi-stage build (builder + runtime)
- Non-root user
- COPY only what's needed to run (no dev files, no .git)
- Health check endpoint: [PATH]

19. Explain a Complex Codebase Section [Extended Thinking]

Explain what this code does and why it's structured this way.

<code>
[PASTE_CODE_SECTION]
</code>

My background: [YOUR_LEVEL — e.g. "comfortable with Python, new to async patterns"]

Output:
1. What it does (2 sentences, plain language)
2. The key design decision and why it was made this way (not just what)
3. What breaks if you change [SPECIFIC_LINE_OR_PATTERN]
4. One thing you'd change and why

20. Generate Structured Logging for an Existing Function [Standard]

Add structured logging to this function without changing its behavior.

[PASTE_FUNCTION]

Logging requirements:
- Library: [structlog / python-json-logger / Winston / Pino / etc.]
- Log entry point (function called) with input shape (not values)
- Log exit point with output shape and duration in ms
- Log each exception with the error type and the failed operation name
- Do not log PII fields: [LIST_SENSITIVE_FIELDS]

Section 3: Analysis and Research Prompts (10 Prompts)

Claude’s 200K context window makes it viable for document synthesis tasks that previously required chunking pipelines. These prompts are designed for the kind of analysis workflow where you’re passing real source material into Claude — not asking it to generate from memory.

For teams building multi-step AI research pipelines that chain Claude with data sources, the implementation patterns covered in AI Content Automation Playbook for One-Person SaaS Teams (2026 Stack) apply directly to the prompts below.

21. Synthesize Multiple Documents into a Brief [Extended Thinking]

Synthesize these [N] documents into a structured brief.

<documents>
[PASTE_DOCUMENTS — keep total under 70K tokens for best synthesis quality]
</documents>

Brief structure:
- Executive summary (3 bullet points, each under 25 words)
- Key findings by theme (not by document — group across sources)
- Conflicts or contradictions between sources (flag explicitly)
- What's missing: gaps none of the sources address
- Recommended next steps

Why it works: The “group across sources” instruction prevents the common output pattern of “Document 1 says X, Document 2 says Y” — producing thematic synthesis instead of sequential summaries. Keep total input under 70K tokens; synthesis quality degrades noticeably above that threshold.

22. Competitive Intelligence Report from Scraped Content [Standard]

Analyze this competitor content and produce an intelligence report.

Competitor: [COMPANY]
Content: [PASTE_SCRAPED_PAGES_OR_NOTES]

Report sections:
1. Positioning: how they describe themselves vs. how they describe the problem
2. Proof points used: named customers, specific metrics, certifications
3. Content gaps: topics in our product space they don't address
4. Tone and audience signals: who are they writing for?
5. One recommendation: where can we outposition them with a specific content piece?

23. Data Interpretation from Raw Output [Standard]

Interpret this data output. Do not summarize — interpret.

Data:
[PASTE_CSV_OR_TABLE_OR_QUERY_RESULT]

Context: [WHAT_THIS_DATA_MEASURES], [TIME_PERIOD], [SAMPLE_SIZE]

Questions to answer:
1. What is the most surprising finding (relative to baseline or expectation)?
2. What is the most actionable finding?
3. What should we NOT conclude from this data (what it doesn't show)?
4. What additional data would change the interpretation most?

24. Rapid Literature Review [Extended Thinking]

Produce a rapid literature review on: [TOPIC]

Based on these abstracts and excerpts:
[PASTE_ABSTRACTS]

Output:
- Consensus view (what most sources agree on)
- Active debates (where sources disagree and why)
- Methodological note: any sources using weaker methodology than the others?
- One open question the literature hasn't addressed
- 3 citations formatted as [Author, Year, Title] for the strongest claims

25. Interview Transcript Analysis [Standard]

Analyze this interview transcript for insights.

Transcript:
[PASTE_TRANSCRIPT]

Extract:
1. Top 3 stated pain points (direct quotes, not paraphrases)
2. Top 3 unstated tensions (what the subject implied but didn't say directly)
3. Jobs-to-be-done: what are they actually trying to accomplish?
4. Language patterns: specific words or phrases they repeated (these become copy)
5. One thing that surprised you about this interview

26. Meeting Notes to Action Items [Standard]

Convert these meeting notes to a structured action item summary.

Notes: [PASTE_NOTES]
Attendees: [LIST_NAMES_AND_ROLES]

Output format:
- Decisions made (what was agreed, not what was discussed)
- Action items: [Owner] — [Task] — [Due date if mentioned]
- Open questions: items raised but not resolved
- Next meeting agenda items

Do not include discussion points that didn't result in a decision or action.

27. Survey Response Thematic Coding [Extended Thinking]

Thematically code these open-ended survey responses.

Question asked: "[SURVEY_QUESTION]"
Responses (N=[NUMBER]):
[PASTE_RESPONSES]

Output:
- Top 5 themes with frequency count
- Representative quote for each theme
- Edge case responses that don't fit any theme
- What % of respondents expressed each theme (approximate)
- One unexpected finding

28. Financial Document Summary [Standard]

Summarize this financial document for a non-finance executive.

Document: [PASTE_EARNINGS_REPORT_OR_10K_SECTION]

Output:
- Top line numbers: revenue, growth rate, margin (one sentence each)
- The one metric management emphasized most — and whether it was up or down
- The risk factor that most changed vs. last period
- What this means for [OUR_COMPANY / OUR_INVESTMENT / OUR_INDUSTRY] in one paragraph

Do not explain what financial terms mean — assume they know P&L, CAC, LTV.

29. Hypothesis Testing from Data [Extended Thinking]

Test this hypothesis against the available data.

Hypothesis: [STATE_HYPOTHESIS]
Data: [PASTE_DATA]
Context: [WHAT_BASELINE_OR_CONTROL_EXISTS]

Output:
- Does the data support, refute, or fail to test the hypothesis?
- What's the strongest evidence for the hypothesis?
- What's the strongest evidence against it?
- What confounding variable is most likely distorting the result?
- Confidence level: High / Medium / Low — with one-sentence justification

30. Trend Identification from Scraped Headlines [Standard]

Identify emerging trends from these headlines/summaries.

Source: [PUBLICATION_OR_FEED], [DATE_RANGE]
Content:
[PASTE_HEADLINES_OR_SUMMARIES]

Output:
- 3 signal trends (directional shifts with multiple data points)
- 1 noise trend (talked about a lot but not a real shift)
- 1 underreported trend (real but covered by fewer than 20% of sources)
- Implication for [YOUR_INDUSTRY_OR_USE_CASE]

Section 4: SEO and Content Strategy Prompts (10 Prompts)

31. Meta Title and Description Generator [Standard]

Generate 5 meta title + description variants for this page.

Page topic: [DESCRIBE_PAGE]
Target keyword: [PRIMARY_KEYWORD]
Audience: [WHO_IS_SEARCHING]

Title rules: under 60 characters, keyword near start, no clickbait
Description rules: 150-160 characters, includes a benefit claim, ends with a call to action word

Rank the 5 variants from most to least likely to earn a click from a professional audience.

32. Internal Link Audit and Recommendation [Standard]

Identify internal linking opportunities for this article.

Article being linked FROM: [TITLE + URL]
Article being linked TO (target): [TITLE + URL + TARGET_KEYWORD]
Existing content on the site (titles + URLs):
[PASTE_LIST]

Output: for each linking opportunity, give the sentence it should appear in (as modified text)
and the anchor text. Natural anchor text only — no exact-match keyword stuffing.
Max 3 links per article direction.

33. Topic Cluster Map [Extended Thinking]

Map a topic cluster for the pillar keyword: "[PILLAR_KEYWORD]"

Site context: [DESCRIBE_SITE_NICHE_AND_AUDIENCE]
Already published: [LIST_EXISTING_ARTICLES]

Output:
- Pillar page angle (what the main /[keyword]/ page should cover)
- 8-10 supporting cluster articles (title + target keyword + search intent)
- 3 articles to prioritize first (lowest KD, highest intent match)
- Internal link structure: which clusters link to which, and why

34. FAQ Schema from Article Draft [Standard]

Generate FAQ schema (JSON-LD) from this article for Google's FAQ rich result.

Article: [PASTE_ARTICLE_OR_SUMMARY]

Rules:
- 4-6 questions only (Google limits display to 3-4; more risks exclusion)
- Each answer under 300 characters (Google truncates longer answers in SERPs)
- Questions must match real search queries (not internal framing)
- No promotional language in answers

Output: valid JSON-LD block only, ready to paste into <head>.

35. Keyword Gap Analysis from Competitor URLs [Standard]

Identify keyword gaps from these competitor page titles and URLs.

My site focus: [DESCRIBE_NICHE]
Competitor pages:
[PASTE_COMPETITOR_TITLES_AND_URLS]

My published pages:
[PASTE_MY_TITLES]

Output: keywords the competitors rank for that I don't have content for, sorted by
estimated commercial intent (high / medium / low). For each gap, suggest an article
angle that differentiates from the competitor's existing approach.

36. Article Outline Optimized for Featured Snippet [Extended Thinking]

Write an article outline optimized to win the featured snippet for: "[QUERY]"

Current snippet holder: [DESCRIBE_CURRENT_SNIPPET_OR_PASTE_TEXT]
My target audience: [DESCRIBE]
My differentiation: [WHAT_I_KNOW_THAT_CURRENT_SNIPPET_DOESN'T_INCLUDE]

Structure the outline to:
- Answer the query directly in 40-60 words in the intro
- Include a definition or step list that Google can pull as a snippet
- Go deeper than the current snippet on at least 2 dimensions

37. Programmatic Content Template [Standard]

Create a reusable article template for [PROGRAMMATIC_CONTENT_TYPE].

Variables the template will swap per page: [LIST_VARIABLES — e.g. {city}, {service}, {price}]
Minimum word count per page: [N]
Must include: [REQUIRED_SECTIONS]
Must differentiate each page with: [UNIQUE_DATA_POINT_SOURCE]

Output: the template with [VARIABLE] placeholders, plus one fully rendered example using
[SAMPLE_VALUES].

38. Headline A/B Test Variants [Standard]

Write 8 headline variants for this article for A/B testing.

Article topic: [DESCRIBE]
Target keyword: [KEYWORD]
Current title: [EXISTING_TITLE]

Vary: question vs. statement, number vs. no number, benefit-first vs. problem-first,
long (60 char) vs. short (40 char). Label each variant with the formula it uses.
Do not use: "Ultimate guide", "Everything you need to know", clickbait superlatives.

39. Content Refresh Plan for Declining Post [Extended Thinking]

Create a refresh plan for this declining post.

Post: [TITLE + URL]
Original publish date: [DATE]
Current traffic trend: [DOWN X% over Y months]
Competing pages that outrank it now: [PASTE_SERP_COMPETITORS]
Current content (paste or summarize): [PASTE]

Output:
- Root cause hypothesis for the ranking drop (2-3 candidates)
- 5 specific changes to make (sections to update, data to add, angle to sharpen)
- Sections safe to keep as-is
- Redirect recommendation (if the URL slug is the problem)

40. Schema Markup Recommendations [Standard]

Recommend the correct Schema.org markup types for this page.

Page type: [ARTICLE / PRODUCT / LOCAL_BUSINESS / HOW_TO / REVIEW / etc.]
Page content summary: [DESCRIBE]

For each recommended schema type:
- Which properties are mandatory for Google's rich results
- Which properties are optional but improve CTR
- Any schema types NOT to use on this page (and why)
Output: JSON-LD skeleton with mandatory properties filled in from the content description.

Section 5: Business and Productivity Prompts (10 Prompts)

41. Product Requirements Document (PRD) Skeleton [Extended Thinking]

Draft a PRD skeleton for this feature.

Feature: [ONE_SENTENCE_DESCRIPTION]
User problem it solves: [PASTE_USER_RESEARCH_OR_FEEDBACK]
Scope: [IN_SCOPE] and explicitly NOT in scope: [OUT_OF_SCOPE]
Success metric: [HOW_WILL_WE_MEASURE_IF_THIS_WORKED]

Output: PRD outline with section headers only + 2-3 bullet points per section.
No prose paragraphs — this is a skeleton for the team to fill in.
Flag the 2 decisions that need leadership alignment before development starts.

42. Job Description (Non-Generic) [Standard]

Write a job description for: [ROLE_TITLE]

Context: [COMPANY_SIZE], [STAGE], [TEAM_STRUCTURE]
What makes this role unusual: [SPECIFIC_CHALLENGE_OR_OPPORTUNITY]
Must-have skills (non-negotiable): [LIST]
Nice-to-have skills: [LIST]

Rules:
- No corporate boilerplate ("fast-paced environment", "wear many hats")
- Lead with what the person will actually DO in week 1, month 3, year 1
- Include one honest "this role is hard because..." line
- Salary range: [RANGE] — include it in the description

43. Investor Update Draft [Standard]

Draft a monthly investor update.

Period: [MONTH YEAR]
Key metrics: [PASTE_METRICS — MRR, growth, churn, runway, headcount]
Wins: [LIST]
Challenges (be direct): [LIST]
What we need from investors: [SPECIFIC_ASK — intros, advice, nothing]

Format: 350-400 words. Direct. No spin. Investors read 20 of these — they reward honesty
over optimism. Lead with the metric that changed most vs. last month.

44. Customer Objection Response Scripts [Standard]

Write response scripts for these sales objections.

Product: [PRODUCT_NAME + ONE_LINE_DESCRIPTION]
Objections:
1. [OBJECTION_1 — e.g. "It's too expensive"]
2. [OBJECTION_2]
3. [OBJECTION_3]

For each:
- Acknowledge (one sentence — no "I understand your concern" boilerplate)
- Reframe (one sentence — change what the objection is measuring)
- Proof (one specific customer example or data point)
- Forward (one question that moves the conversation forward)

45. Process Documentation from SME Interview Notes [Standard]

Convert these SME interview notes into a standard operating procedure.

Process: [PROCESS_NAME]
Notes: [PASTE_INTERVIEW_NOTES]

SOP format:
- Purpose (one sentence)
- Prerequisites (what must be true before starting)
- Steps (numbered, imperative verb, one action per step)
- Decision points (IF condition THEN step X, ELSE step Y)
- Common mistakes (with how to recover)
- Owner: [ROLE] | Last reviewed: [DATE]

46. Board Presentation Slide Outline [Extended Thinking]

Outline a board presentation on: [TOPIC]

Context: [WHAT_DECISION_THE_BOARD_NEEDS_TO_MAKE]
Available data: [WHAT_METRICS_AND_EVIDENCE_WE_HAVE]
Time slot: [N] minutes

Output: one slide title + 3 speaker notes bullets per slide.
Order slides to build to the decision — not to tell the story chronologically.
Flag the one slide most likely to generate questions and suggest pre-answers for 2 likely questions.

47. Vendor Evaluation Scorecard [Standard]

Build a vendor evaluation scorecard for: [PURCHASE_DECISION]

Vendors being evaluated: [LIST]
Our must-haves: [LIST]
Evaluation dimensions: [LIST_5-7_CRITERIA]
Budget: [RANGE]
Timeline: [WHEN_WE_NEED_TO_DECIDE]

Output: scored matrix with 1-5 scale per criterion + weighting (must-haves = 2x weight).
For the top-scoring vendor: identify the one risk worth flagging before signing.

48. Training Script for New Hire Onboarding [Standard]

Write a training script for: [SKILL_OR_PROCESS]

New hire background: [WHAT_THEY_ALREADY_KNOW]
What they must be able to do after training: [SPECIFIC_OUTCOME]
Common mistakes new hires make: [LIST]

Format:
- 5-minute verbal walkthrough script (what the trainer says)
- 3 practice exercises (with success criteria)
- Check-for-understanding questions (with correct answers)
- "Gotcha" callout box for the #1 mistake to avoid

49. Customer Success Playbook for Specific Segment [Standard]

Write a customer success playbook for segment: [SEGMENT — e.g. "enterprise accounts, 100+ seats"]

Product: [PRODUCT_NAME]
Typical failure mode for this segment: [WHAT_CAUSES_CHURN_OR_EXPANSION_FAILURE]
Expansion signals (when to reach out about upsell): [LIST_TRIGGERS]

Playbook sections:
- Onboarding sequence (days 1, 7, 30, 90)
- Health score indicators (what to watch in the product data)
- Escalation trigger: when to bring in [SALES / LEADERSHIP / SUPPORT]
- Renewal conversation: what to say 90 days before renewal

50. Retrospective Facilitation Agenda [Standard]

Create a retrospective agenda for a [SPRINT / QUARTER / PROJECT] retro.

Team size: [N] people
Time available: [N] minutes
What went well that we want to repeat: [OPTIONAL_SEED]
Known tension to address: [OPTIONAL_SEED]

Output: timed agenda with facilitator instructions per segment, 2 specific discussion
questions per segment (not generic "what went well?"), and one action item format
to use at the close (who / what / by when).

Frequently Asked Questions

What makes a good Claude Sonnet 4.6 prompt?

Structure and specificity. Claude responds best to prompts with: clear input/output format instructions, explicit constraints (word counts, banned words, formatting rules), and XML-tagged system prompts for multi-constraint tasks. Generic prompts produce generic output regardless of model quality.

Should I always use extended thinking mode?

No. Extended thinking adds 20–40% to output token counts on complex tasks. Use it for analysis, outline generation, debugging, and multi-step reasoning. Turn it off for straight drafting, summarization, and classification tasks where the reasoning overhead isn’t needed.

How do I use these prompts via the Anthropic API?

Copy the System:-prefixed content into the system field of your API call. The user-turn prompt goes in the messages array. For extended thinking, add "thinking": {"type": "enabled", "budget_tokens": 5000} to your request body. Full API setup and cost optimization patterns are covered in our Claude API for Business guide.

Do these prompts work with Claude Opus 4.6 or Haiku 4.5?

All prompts work across the Claude 4.x family. Opus 4.6 will produce higher-quality output on complex reasoning prompts (sections 3 and 5) at 5× the cost. Haiku 4.5 works well for classification, simple extraction, and short-form generation tasks (prompts 9, 10, 26, 30) at a fraction of the cost.

How is this library different from the other Claude prompt collections?

These are production prompts with explicit failure mode documentation — what breaks without a specific constraint, and why. Most prompt libraries are aspirational (“try asking Claude X”). This library reflects 3 months of iteration on what actually ships reliably in professional workflows.

Can I use these prompts with Claude Code CLI?

Yes. The coding prompts (11–20) work directly in Claude Code. For system prompts in the CLI, use the --system flag or a CLAUDE.md file in your project root. Claude Code automatically respects project-level CLAUDE.md instructions without a separate system prompt per call.

Last updated: 2026-08-03 | All prompts tested on claude-sonnet-4-6 (Anthropic, released February 2026). Extended thinking available on Sonnet 4.6 and Opus 4.6 via API.