Best Claude Prompts: Templates, Examples, and Built-In Tools

Anthropic's prompt improver increased classification accuracy by 30% in internal testing, by restructuring existing prompts with chain-of-thought reasoning and XML tags. That gap between a raw prompt and a structured one is larger than most users realize.

The issue isn't that people write bad prompts. Claude processes instructions differently than other models: it follows directions literally, which means vague prompts produce vague outputs, but specific prompts produce surprisingly specific results. The difference between "summarize this document" and a structured prompt with XML-tagged context, output constraints, and two worked examples can be the difference between a generic paragraph and an analysis you'd actually send to a client.

Most Claude prompt guides recycle generic advice that applies to any LLM. What they miss are the tools and techniques built specifically for Claude: Anthropic's Console prompt generator that solves the blank page problem, the prompt improver that automatically applies best practices, and the template variables system that makes prompts reusable across API calls.

This guide covers all three, along with copy-ready templates across seven categories and the formatting techniques that Claude responds to better than other models.

Three tools in the Anthropic Console address different stages of prompt development. Most Claude users never open the Console, which is a missed opportunity.

The Prompt Generator The Console includes a prompt generator that creates production-ready templates from plain-language task descriptions. Describe what you want Claude to do ("classify customer support tickets by urgency and route them to the right team"), and the generator produces a structured prompt with XML tags, template variables, and chain-of-thought instructions.

This solves what Anthropic calls the "blank page problem." Instead of guessing at prompt structure, you get a working first draft that follows prompt engineering best practices. The underlying metaprompt is public: Anthropic published a Google Colab notebook showing how the generator works, so you can run it programmatically or adapt it for your own tooling.

The Prompt Improver

The prompt improver takes an existing prompt and restructures it through four steps: identifying examples in your prompt, creating a cleaner structure with XML tags, adding chain-of-thought reasoning instructions, and updating examples to demonstrate the new reasoning process. You can watch each step happen in real time in the Console.

In Anthropic's testing, the improver increased accuracy by 30% on a multilabel classification task and brought word count adherence to 100% on a summarization task. The gains come primarily from adding structured reasoning steps that guide Claude through the problem before it generates output.

You can feed the improver optional feedback about current issues ("summaries are too basic for expert audiences") and include example input/output pairs. The more context you give it, the more targeted the improvements.

Template Variables

The Console supports template variables using {{double bracket}} syntax. Write a prompt once with placeholders like {{customer_message}} or {{product_category}}, then swap values across different test runs without rewriting the prompt.

This separation of prompt logic from input data lets you version-control templates independently, A/B test different inputs against the same instructions, and scale to production without copy-pasting. Variables also works alongside the Console's evaluation tool, so you can run your template against test datasets and track accuracy across versions.

For cleaner variable handling, wrap them in XML tags:

<customer_message>
{{customer_message}}
</customer_message>

This makes it unambiguous where user input starts and ends, which matters when your prompt mixes instructions with dynamic content.

The most effective Claude prompts share three traits: they specify the output format, provide context about the task, and include at least one example of the desired result. Here are templates across seven categories that you can copy and adapt.

1. Code Review and Refactoring

You are a senior software engineer reviewing code for production readiness.

<code_to_review>
{{code}}
</code_to_review>

Review this code for:
1. Bugs or logic errors
2. Security vulnerabilities
3. Performance issues
4. Readability improvements

For each issue, provide the specific line, why it's a problem, and a corrected version.
If the code is production-ready, say so and explain why.

This works because it gives Claude a concrete role, structures input with XML tags, and specifies both evaluation criteria and output format.

2. Content Editing

Edit the following text for clarity and conciseness. Preserve the author's voice.

<text>
{{text}}
</text>

<guidelines>
- Cut word count by 20% without losing meaning
- Replace passive voice with active voice
- Flag factual claims that need verification
- Keep technical terms but simplify jargon
</guidelines>

Return the edited text, then a summary of changes.

3. Data Extraction

Extract structured data from this document.

<document>
{{document_content}}
</document>

<schema>
For each entity, extract:
- Name: string
- Date: ISO 8601 format
- Amount: numeric, USD
- Category: one of [invoice, payment, refund, adjustment]
- Confidence: high, medium, or low
</schema>

Return results as a JSON array. Use null for fields that cannot be determined.

For large-scale document extraction, tools like Fast.io's Metadata Views can automate this across entire workspaces, turning uploaded documents into queryable structured data without writing individual prompts per file.

4. Analysis and Research

<context>
{{research_data}}
</context>

Analyze the data above and answer: {{research_question}}

Structure your response as:
1. Key findings (3-5 bullet points)
2. Supporting evidence with specific numbers from the data
3. Limitations of this analysis
4. Recommended next steps

If the data is insufficient, say so and explain what additional information would help.

5. Summarization

Summarize the following for {{audience_type}}.

<content>
{{content}}
</content>

Requirements:
- Length: {{word_count}} words
- Focus on actionable takeaways, not background
- Use bullet points for key facts
- End with one sentence on why this matters to the audience

Do not include information not in the source.

6. Creative Writing

Write a {{content_type}} about {{topic}}.

<style_guide>
Tone: {{tone}}
Audience: {{audience}}
Length: {{length}}
Avoid: clichés, passive voice, unnecessary adverbs
</style_guide>

<example>
{{example_of_desired_style}}
</example>

Start directly with the content. No preamble.

7. Business Communication

Draft a {{communication_type}} about {{topic}}.

<context>
Sender: {{sender_role}}
Recipient: {{recipient_role}}
Relationship: {{relationship_context}}
Goal: {{desired_outcome}}
</context>

<constraints>
- Professional but conversational
- Under {{word_limit}} words
- Include a clear call to action
- Anticipate and address likely objections
</constraints>

Each template uses three Claude-specific patterns: XML tags for separating instructions from data, template variables for reuse, and explicit output constraints that reduce ambiguity.

Store prompt templates where your whole team can find them

Fast.io gives agents and humans 50GB of shared workspace storage with built-in RAG for searching prompt libraries by meaning. No credit card, no trial.

Sign Up Free

XML Tags for Structure

Claude responds to XML tags more reliably than markdown headers or numbered sections when you need to separate different types of content in a single prompt. Tags like <instructions>, <context>, <examples>, and <output_format> tell Claude exactly where each piece of information starts and ends.

This matters most when your prompt mixes instructions with dynamic input. Without tags, Claude can mistake a paragraph from your context document for an instruction. With tags, the boundaries are clear.

For nested data, use indexed tags:

<documents>
  <document index="1">
    <source>quarterly_report.pdf</source>
    <content>{{doc_1}}</content>
  </document>
  <document index="2">
    <source>competitor_analysis.xlsx</source>
    <content>{{doc_2}}</content>
  </document>
</documents>

Few-Shot Examples

Include 3 to 5 examples wrapped in <example> tags. This is one of the highest-return techniques available for Claude. A few diverse examples shift Claude's output format, tone, and level of detail more reliably than pages of written instructions.

Make your examples diverse enough to cover edge cases. If you're building a classifier, include at least one ambiguous case and show how you want it handled. Claude generalizes from the pattern rather than memorizing the specific examples.

Chain-of-Thought Prompting

For tasks where accuracy matters more than speed, add explicit reasoning steps. Three approaches, from simplest to most controlled:

1. Add "Think through this step by step before answering" to your prompt
2. Write out the specific reasoning steps you want Claude to follow
3. Use <thinking> and <answer> tags to separate reasoning from the final output

The structured approach is most useful in production because you can extract just the <answer> content programmatically while keeping the reasoning for debugging and audits.

Long Context Placement

When working with documents over 20,000 tokens, put the documents at the top of your prompt and your question at the bottom. Anthropic's testing shows this placement can improve response quality by up to 30%.

Ask Claude to quote relevant passages before answering. This "ground in quotes" technique forces Claude to locate specific evidence rather than generating from training data, which reduces hallucination on document-specific questions.

A single well-crafted prompt is useful. A library of tested, versioned prompts that your whole team can access is what turns prompt engineering from a personal skill into team infrastructure.

Version control your prompts the same way you version code. Store templates as files with {{variable}} placeholders in a git repository. Track changes, review diffs, and roll back when a prompt revision performs worse than its predecessor.

Test prompts before deploying them. The Anthropic Console's evaluation tool lets you run a template against a dataset of inputs and measure outputs against your success criteria. Build a test suite of 20 to 50 examples that cover your common cases and known edge cases, then run it every time you modify a prompt.

For teams running AI agents that consume prompt templates at scale, the files need to live somewhere every agent and team member can reach. Local filesystems break down when agents run across different environments. Generic cloud storage (S3, Google Drive) works for hosting but doesn't help you find the right template when you have hundreds.

Intelligent workspaces like Fast.io solve this by auto-indexing uploaded files for semantic search. Upload your prompt library, enable Intelligence Mode on the workspace, and both humans and agents can search templates by meaning rather than filename. An agent connected through the Fast.io MCP server can query the workspace for "the customer support classification prompt" and retrieve the right template without knowing its exact path. The free plan includes 50GB of storage and 5,000 AI credits per month, with no credit card required.