7 Claude Prompt Templates That Work Every Time

A claude prompt template is a fill-in skeleton you reuse across tasks instead of writing every prompt from scratch — swap the bracketed parts, keep the structure. Most people never build one. They retype the same rough instructions every session, get inconsistent output, and conclude the model is unpredictable. It is not unpredictable. It is undirected. This guide gives you seven skeletons, each with a copy-paste example, so you have a repeatable prompt structure for almost anything you ask Claude to do.

These are general-purpose templates you adapt per task. For the underlying principles behind why they work, see our Claude prompting guide. If you want ready-made prompts instead of building your own, our best Claude prompts roundup and the Claude prompt generator guide are the faster path.

Why a template beats a blank cursor

A template forces you to decide the four things that actually change output quality — role, context, task, and format — before you hit enter, instead of discovering you left one out after a bad answer. The structure itself is doing the work: Anthropic's own prompt engineering documentation is built around this exact idea, that being explicit about role, context, and the shape of the answer produces more reliable results than a single unstructured sentence.

None of these seven skeletons require any special access or technical setup. They are plain text you type into the Claude app, on any plan. Pick the one that matches your task, fill in the brackets, and send it.

Template 1: Role + Context + Task + Format

This is the default skeleton — reach for it first for any single, well-defined deliverable. It works because it separates who Claude is being, what it knows, what it needs to do, and what the answer should look like, so nothing gets guessed.

ROLE: You are [specific expert role, e.g. "a senior email copywriter"].

CONTEXT: [Background Claude needs - audience, business, constraints,
what has already been tried].

TASK: [The exact deliverable, one sentence. Be specific about scope.]

FORMAT: [Structure, length, tone - e.g. "3 subject lines + 150-word
body, conversational tone, one CTA."]

Ask me clarifying questions first if this brief is incomplete.

The last line matters more than it looks. Without it, Claude will fill gaps with reasonable-sounding guesses instead of flagging them. With it, you find out what you forgot to specify before you get an answer built on the wrong assumption.

Template 2: Ask-then-act

Use ask-then-act when the brief in your head is vaguer than you realize — new projects, first drafts for an unfamiliar audience, or anything where getting it wrong wastes real time. Instead of hoping Claude asks the right follow-up on its own, you require it.

I want you to [end goal, e.g. "write a cold outreach sequence"].

Before you write anything, ask me up to 5 questions that would
change your approach - about audience, goal, constraints, or tone.
Wait for my answers.

Then produce the full [deliverable] using what I told you, without
repeating the questions back to me.

The instinct to skip this step and just describe everything upfront usually backfires — you do not know which details matter until Claude tells you what it is missing. Ask-then-act inverts who does the guessing.

Template 3: Critique loop

The critique loop makes Claude review its own first draft before you see it, which catches the generic phrasing and unearned confidence that a single-pass answer tends to have. It is the single highest- leverage template for anything client-facing or persuasive.

Step 1 - DRAFT: Write [deliverable] based on: [brief].

Step 2 - CRITIQUE: Now switch roles. As a skeptical editor, list the
3 weakest parts of your own draft - where it is generic, where it
contradicts the brief, or where a reader would stop reading.

Step 3 - REVISE: Rewrite the draft fixing only what you flagged in
Step 2. Do not introduce new sections. Show only the final version.

Run this on anything you would normally edit by hand anyway — ad copy, a proposal opening, a difficult email. You get the editing pass for free, and the flagged weaknesses often tell you something about the brief itself, not just the draft.

Template 4: XML-structured

Reach for XML tags the moment a prompt mixes more than two kinds of content — instructions, background context, and examples all in one message. Anthropic's own documentation recommends this explicitly: wrapping each type of content in its own tag reduces the chance Claude blends an example with an instruction or misreads where context ends and the task begins.

<role>You are [expert role].</role>

<context>
[Background info, prior examples, business context - as much as
Claude needs and no more]
</context>

<task>
[Exact task, one to two sentences]
</task>

<examples>
<example>[input] -> [ideal output]</example>
<example>[input] -> [ideal output]</example>
</examples>

<format>
[Output shape: length, structure, sections]
</format>

You do not need exotic tag names — Claude parses any descriptive label you give it, so <client_notes> or <past_examples> work exactly as well as generic ones, as long as you are consistent across the prompt.

Template 5: Few-shot (multishot)

Few-shot prompting teaches Claude a pattern by example instead of by description, and it is the most reliable way to lock in a specific voice or format. Anthropic's guidance is to use three to five examples that are relevant to your real use case and different enough from each other that Claude generalizes the pattern instead of copying one example's specifics.

Match the pattern in these examples. Do not explain the pattern back
to me - just produce output #4 in the same style.

<example>
Input: [example input 1]
Output: [ideal output 1]
</example>

<example>
Input: [example input 2]
Output: [ideal output 2]
</example>

<example>
Input: [example input 3]
Output: [ideal output 3]
</example>

Now do this one:
Input: [your real input]
Output:

The catch is that Claude will faithfully copy whatever is wrong with your examples too — an awkward phrase or a format quirk in example two shows up in the real output. Only feed it examples that represent the quality bar you actually want.

Template 6: Chain-of-thought

Chain-of-thought forces Claude to work through a decision before committing to an answer, which matters most for anything involving analysis, prioritization, or a choice between competing approaches — not for simple rewrites or formatting jobs, where it just adds noise.

Before you answer, think through this step by step inside <thinking>
tags: identify the constraints, weigh 2-3 possible approaches, and
pick one with a one-line reason.

Then, outside the thinking tags, give me only the final
[deliverable] - no visible reasoning in the answer itself.

Task: [your actual task]

Keeping the reasoning inside its own tags is what makes this template usable — you get the benefit of Claude thinking through options without a wall of reasoning cluttering the deliverable you actually wanted.

Template 7: Constraints-and-format lock

This template exists for the situation where format compliance matters more than creativity — a document that has to fit an exact structure, or copy that has to avoid specific words and moves no matter what. State the non-negotiables as MUST and MUST NOT lists instead of burying them in a paragraph of context.

Produce [deliverable] under these constraints:

MUST: [non-negotiable requirements - length, must include X, must
match voice Y]
MUST NOT: [banned words, formats, or moves - e.g. no hedging, no
"in today's fast-paced world", no bullet-only answers]
OUTPUT FORMAT: [exact structure - e.g. "one H1, 3 H2 sections, no
intro paragraph before the H1"]

If you cannot meet a MUST constraint, say so explicitly instead of
producing an output that violates it.

The last line is what prevents silent failures — without it, Claude will sometimes quietly drop a constraint it could not satisfy rather than telling you it could not be done as specified.

Which template for which job

Most tasks fit one skeleton clearly. When you are unsure, start with Template 1 and add a second skeleton on top of it — for example, role+context+task+format wrapped in XML tags, with a critique loop as the last step.

Stacking templates for real work

The seven skeletons are not mutually exclusive, and the best prompts for anything non-trivial usually combine two or three. A client deliverable might use Template 1 for the skeleton, Template 4 to wrap the context and examples in XML tags so nothing gets confused, and Template 3 as a final critique pass before you read the output. For long-form writing specifically, our guide to using Claude for writing shows this stacking in practice across drafts, edits, and voice matching.

A prompt structure is only as good as the specificity you put into the brackets. "[Audience]" filled in as "marketing managers at B2B SaaS companies who have tried three tools already and are skeptical of a fourth" produces a categorically better result than "marketing managers." The template gives you the slots; the work is still filling them in with real detail.

Common mistakes that break these templates

Most template failures come from three habits: leaving the FORMAT section vague ("make it good" is not a format), stuffing five unrelated tasks into one TASK line instead of running them separately, and skipping examples when you actually do have 3-5 good ones sitting in an old document or email thread. Fix those three habits and every template above gets noticeably more reliable.

It also helps to save the filled-in version of a template once it works well, rather than rebuilding it from the blank skeleton every time. A working prompt for your voice, your audience, and your format is worth keeping as a reusable asset — which is the entire idea behind a prompt library.

Frequently asked questions

Do these templates work in Claude Code or Cowork, not just the app?

Yes. The seven skeletons are plain-text prompt structure, not app features, so they work anywhere you talk to Claude — the consumer app, Claude Code, or Cowork. Cowork adds folder-scoped context and skills on top, which pairs especially well with the XML-structured and few-shot templates, since you can point it at a folder of past examples instead of pasting them inline every time.

How long should a claude prompt template actually be?

As long as the task needs and no longer — a Template 1 prompt for a short email might be four lines, while an XML-structured prompt wrapping a full brief and three examples might run twenty. Length is not the goal; every line should be doing something the model would otherwise have to guess at.

Can I combine chain-of-thought with few-shot examples?

Yes, and it is one of the stronger combinations here. Put a <thinking> block inside each example so Claude sees the reasoning pattern, not just the final answer, then it will generalize that same step-by-step approach to the new input you give it at the end of the prompt.

Start with one template this week

Pick whichever task eats the most of your week right now and run it through Template 1 first — role, context, task, format, in that order. Once that habit is automatic, layer in the critique loop for anything client-facing and XML tags for anything long. You do not need all seven in rotation on day one; you need one good prompt structure that you actually reuse instead of retyping from memory every time. For the deeper reasoning behind why structure changes output quality this much, our Claude prompting guide is the place to go next.