Advanced Prompting Techniques

A single well-written prompt only gets you so far. This page covers when to make Claude reason out loud, how to force reliable structured output now that prefilling is deprecated, when to split one task into a validated chain of calls, and how to arrange long documents so Claude actually uses them.

Chain of thought: when reasoning helps, and when it's overhead

☺ Like you're 10: It's the difference between showing your math homework and just blurting out a number — showing the work makes it obvious exactly where a wrong turn happened.

Stepping through a problem before answering reduces errors on math, logic, multi-step analysis, and decisions with many competing factors. It has a second benefit for you as a prompt author: seeing the reasoning trace often reveals exactly where your prompt itself was ambiguous, not just where the model went wrong. The caveat, per Anthropic's docs, is blunt: "Without outputting its thought process, no thinking occurs" — asking Claude to "think it through" silently, without producing any visible reasoning, doesn't do anything.

Three escalating forms

The documentation describes three levels of explicit chain-of-thought prompting, in increasing order of control: basic — simply add "Think step-by-step"; guided — outline the specific steps Claude should follow; and structured — use XML tags to separate reasoning from the final output, typically <thinking> for the working and <answer> for the result you'll parse out.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": (
                "A store had 120 units of a product. It sold 35% in week one "
                "and 20% of what remained in week two. How many units are left?\n\n"
                "Work through this step by step inside <thinking> tags, then give "
                "the final number inside <answer> tags."
            ),
        }
    ],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content:
        "A store had 120 units of a product. It sold 35% in week one " +
        "and 20% of what remained in week two. How many units are left?\n\n" +
        "Work through this step by step inside <thinking> tags, then give " +
        "the final number inside <answer> tags.",
    },
  ],
});

for (const block of response.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}

Current models default to adaptive thinking

Claude Fable 5, Opus 5, and Sonnet 5 support "adaptive thinking" — the model decides for itself when and how much to reason, driven by an effort parameter and the complexity it detects in your query — rather than the older manual extended-thinking mode. Manual step-by-step chain-of-thought prompting is now positioned as a fallback: useful when thinking is turned off, or on Haiku 4.5, which runs the reverse configuration (it supports manual extended thinking via thinking.type: "enabled", but not adaptive thinking). The docs' general recommendation is to prefer a broad instruction like "think thoroughly" over a hand-written step-by-step plan, since Claude's own reasoning often outperforms a human-authored one.

Prefilling: a legacy technique, and what replaces it

☺ Like you're 10: Prefilling used to be like finishing someone's sentence for them so they couldn't wander off-topic. The newest models say "finish your own sentence" — but they'll happily fill out a form for you if you hand them the blank one (that's Structured Outputs).

Historically, you could supply a partial assistant turn — the last message in the array with role: "assistant" — and Claude would continue writing from exactly where you left off. Prefilling { forced the response to start as JSON; prefilling a tag like <analysis> skipped Claude's preamble and forced a structured section to open immediately. It looked like this:

{
  "messages": [
    {"role": "user", "content": "Return the user's name and age as JSON."},
    {"role": "assistant", "content": "{"}
  ]
}

The docs give explicit replacements for the two most common reasons people used to prefill:

• Forcing a format like JSON — use Structured Outputs (output_config.format with type: "json_schema"), or define a single extraction tool with strict: true and force it via tool_choice. Both guarantee schema-conformant output; prefilling only ever nudged Claude toward it.
• Eliminating a preamble like "Here is the requested summary:" — just instruct directly ("Respond with only the summary — no introductory sentence"), or rely on XML tags, Structured Outputs, or tool calling, and strip any stragglers in post-processing.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Extract the name and age from: Jordan is 34."}
    ],
    output_config={
        "format": {
            "type": "json_schema",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                },
                "required": ["name", "age"],
                "additionalProperties": False,
            },
        }
    },
)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Extract the name and age from: Jordan is 34." },
  ],
  output_config: {
    format: {
      type: "json_schema",
      schema: {
        type: "object",
        properties: {
          name: { type: "string" },
          age: { type: "integer" },
        },
        required: ["name", "age"],
        additionalProperties: false,
      },
    },
  },
});

Prompt chaining: breaking one big task into a validated sequence

Anthropic's "Building Effective Agents" pattern for prompt chaining decomposes a task into a sequence of steps, where each LLM call processes the previous step's output, with programmatic "gates" checking progress before the next call runs. It's best suited to tasks that decompose cleanly into fixed subtasks — it trades latency for higher accuracy by giving each individual call one thing to do well.

Because adaptive thinking and native subagent orchestration now handle a lot of multistep reasoning inside a single call, the current prompting docs frame explicit chaining as most valuable specifically when you need to inspect intermediate outputs or enforce a fixed pipeline structure. The most common named pattern is self-correction: generate a draft, review it against stated criteria, then refine based on that review — each stage a separate API call, so you can log, evaluate, or branch at any point.

draft = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": f"Write a 150-word product description for: {product_brief}"}
    ],
)
draft_text = next(b.text for b in draft.content if b.type == "text")

review = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=512,
    messages=[
        {
            "role": "user",
            "content": (
                "Review this product description against our style guide "
                "(no exclamation points, active voice, under 150 words). "
                "List concrete issues, or say 'No issues found.'\n\n"
                f"<description>\n{draft_text}\n</description>"
            ),
        }
    ],
)
review_text = next(b.text for b in review.content if b.type == "text")

if "No issues found" not in review_text:
    refined = client.messages.create(
        model="claude-sonnet-5",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": (
                    "Revise this description to fix the issues listed.\n\n"
                    f"<description>\n{draft_text}\n</description>\n\n"
                    f"<issues>\n{review_text}\n</issues>"
                ),
            }
        ],
    )
    final_text = next(b.text for b in refined.content if b.type == "text")
else:
    final_text = draft_text

const draft = await client.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [
    { role: "user", content: `Write a 150-word product description for: ${productBrief}` },
  ],
});
const draftText = draft.content.find((b) => b.type === "text")?.text ?? "";

const review = await client.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 512,
  messages: [
    {
      role: "user",
      content: `Review this product description against our style guide (no exclamation points, active voice, under 150 words). List concrete issues, or say "No issues found."\n\n<description>\n${draftText}\n</description>`,
    },
  ],
});
const reviewText = review.content.find((b) => b.type === "text")?.text ?? "";

let finalText = draftText;
if (!reviewText.includes("No issues found")) {
  const refined = await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: `Revise this description to fix the issues listed.\n\n<description>\n${draftText}\n</description>\n\n<issues>\n${reviewText}\n</issues>`,
      },
    ],
  });
  finalText = refined.content.find((b) => b.type === "text")?.text ?? "";
}

Long-context prompting: document placement and quote grounding

☺ Like you're 10: It's like handing someone a stack of paperwork — if you actually want them to use page 40, don't bury it at the bottom of the pile after you've already asked your question. Put it on top first.

For inputs of roughly 20,000+ tokens, place the long document content near the top of the prompt — above your query, instructions, and examples. The docs state this ordering "improves performance across all models," and that putting the query at the end can improve response quality "by up to 30 percent in tests," especially for complex multi-document inputs. Structure multi-document content with XML: wrap each document in <document> tags containing <source> and <document_content> subtags, adding an index attribute when there are several.

document_block = """<documents>
  <document index="1">
    <source>annual_report_2023.pdf</source>
    <document_content>{annual_report}</document_content>
  </document>
  <document index="2">
    <source>competitor_analysis_q2.xlsx</source>
    <document_content>{competitor_analysis}</document_content>
  </document>
</documents>

Analyze the annual report and competitor analysis. Identify strategic
advantages and recommend Q3 focus areas.""".format(
    annual_report=annual_report_text,
    competitor_analysis=competitor_analysis_text,
)

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=2048,
    messages=[{"role": "user", "content": document_block}],
)

For grounding, ask Claude to extract the relevant passages into <quotes> tags before doing the actual task, rather than jumping straight to analysis. This is the same word-for-word quote-extraction technique documented in Anthropic's hallucination-reduction guidance for documents over 20k tokens: it keeps Claude anchored to what the source actually says instead of drifting toward plausible-sounding but unsupported claims, and it gives you a visible trail to check its work against.

Common anti-patterns