AI-generated document — produced by an AI as part of an experiment; it may contain errors.
Effective Prompting Tactics for Claude and Other LLMs
A ranked, source-grounded reference. Compiled from official Anthropic and OpenAI documentation/engineering writing and recent peer-reviewed and empirical research. Last compiled: June 2026.
Overview
This guide collects the prompting tactics that most reliably improve four outcomes: accuracy, fewer duplicate/redundant calls, response speed, and token efficiency. Tactics are ranked by overall impact (Critical → Low), weighted most heavily toward accuracy, since the other three objectives matter little if the output is wrong.
Two framing points from the source material are worth stating up front, because every tactic below sits inside them:
- Start by defining success and testing against it. Both Anthropic and OpenAI present clear success criteria plus evaluations as the prerequisite to prompt engineering, not an afterthought — you cannot tune what you cannot measure, and OpenAI additionally recommends pinning to specific model snapshots so results stay comparable as you iterate (OpenAI, Prompt engineering; Anthropic, Prompting best practices).
- Treat context as a finite resource. Anthropic’s central principle for modern (especially agentic) work is to find “the smallest possible set of high-signal tokens that maximize the likelihood of [the] desired outcome” — because model accuracy degrades as the context window fills (“context rot”) (Anthropic, Effective context engineering for AI agents). Many tactics below are really applications of this one idea.
How to read the tags. Each tactic carries two markers:
- Serves — which objective(s) it advances: Accuracy, Fewer calls, Speed, Tokens.
- Where — the usage context(s) it applies to: Chat (conversational use), API (programmatic single calls), Agentic (tool-using, multi-step, multi-call workflows).
A note on model type: newer “reasoning” models (e.g., Claude with adaptive thinking, OpenAI o-series/GPT-5) reason internally and need less hand-holding than older models. Several tactics change shape for these models; watch-outs flag this where relevant.
Quick Reference (ranked by impact)
Critical
- Be clear, direct, and specific
- Provide well-chosen examples (few-shot / multishot)
- Structure the prompt — tags/sections + smart ordering
- Prompt caching: put stable content first
High
- Add context and motivation (the “why”)
- Calibrate reasoning to task difficulty
- Require self-checking / verification
- Decompose, chain, and persist on complex tasks
- Engineer minimal, high-signal context and curate tools
- Manage long-horizon context (compaction, notes, tool-result clearing, sub-agents)
- Use parallel tool calls
- Reduce latency through model selection, output length, and streaming
- Ground answers and permit “I don’t know”
Medium
- Assign a clear role / persona
- Specify an explicit output format (e.g., structured / JSON)
Low
- Use positive framing (say what to do, not what not to do)
- Use concise-reasoning styles (Chain-of-Draft) for speed/cost
Detail View
1. Be clear, direct, and specific — Critical
Serves: Accuracy · Where: Chat, API, Agentic
How to use. State exactly what you want, including the desired output format and any constraints. Use numbered steps when order or completeness matters. Anthropic’s rule of thumb: if a colleague with minimal context would be confused by your prompt, the model will be too (Anthropic, Prompting best practices). OpenAI frames non-reasoning GPT models as benefiting from precise, explicit instructions (OpenAI, Prompt engineering).
Why it helps / impact. This is the single highest-leverage lever on accuracy. Ambiguity is the most common cause of a wrong-but-plausible answer, and a wrong answer wastes the call entirely. Specificity also reduces follow-up clarification rounds (fewer calls).
Example.
- Weak: “Summarize this report.”
- Strong: “Summarize this report in 5 bullet points for an executive audience. Each bullet ≤20 words. Lead with the financial impact.”
Watch-outs. “Specific” is not “verbose”: padding the prompt with low-signal detail dilutes attention (see Tactic 9). Don’t over-specify brittle step-by-step logic for capable models; give strong heuristics instead.
2. Provide well-chosen examples (few-shot / multishot) — Critical
Serves: Accuracy · Where: Chat, API
How to use. Include a few input→output examples showing the exact format, tone, and edge-case handling you want. Anthropic recommends 3–5 examples that are relevant (mirror your real case) and diverse (vary enough that the model doesn’t latch onto an unintended pattern), wrapped in <example> tags. OpenAI similarly recommends showing a diverse range of inputs with desired outputs (Anthropic, Prompting best practices; OpenAI, Prompt engineering).
Why it helps / impact. Anthropic calls examples one of the most reliable ways to steer output and notes they can dramatically improve accuracy and consistency; in its context-engineering guidance it treats well-chosen examples as more informative to the model than long written rule lists — “examples are the ‘pictures’ worth a thousand words” (Anthropic, Effective context engineering for AI agents). Consistency, in turn, reduces re-runs. Recent empirical work shows that as available context grows, many-shot ICL (dozens to hundreds of examples) can outperform zero- and few-shot regimes on capable models like GPT-4o when used as evaluators (Song et al., COLING 2025).
Example. For sentiment tagging, show three labeled reviews (one positive, one neutral, one negative) before the unlabeled input, so the model copies the exact one-word label format.
Watch-outs. Don’t stuff a “laundry list” of every edge case — Anthropic explicitly advises curating a small canonical set instead. Example position matters within the demonstration block: across 10 LLMs, attention to structured items follows an “attention basin,” peaking at the beginning and end of the sequence and dipping in the middle, so place the most informative examples at the start or end of the block rather than buried in the middle (Yi et al., 2025). For reasoning models, OpenAI recommends trying zero-shot first and adding examples only if needed (OpenAI, Reasoning best practices).
Serves: Accuracy, Tokens · Where: Chat, API, Agentic
How to use. Separate the moving parts of a prompt — instructions, context, examples, input data — using XML tags (<instructions>, <context>, <input>) and/or Markdown headers, with consistent, descriptive names. For long inputs, put the long documents at the top and the question/instructions at the end. OpenAI suggests an Identity → Instructions → Examples → Context ordering in developer messages (Anthropic, Prompting best practices; OpenAI, Prompt engineering).
Why it helps / impact. Clear delineation reduces the chance the model misreads data as instructions (also a mild prompt-injection safeguard). Anthropic reports that for long, multi-document inputs, placing the query at the end can improve response quality by up to ~30% in their tests (Anthropic, Prompting best practices). This ordering effect has a mechanistic basis: empirical work across 10 LLMs documents an attention basin — models systematically allocate more attention to items at the beginning and end of a structured sequence and less to the middle — so the most important content earns better attention when placed at the edges (Yi et al., 2025).
Example.
<documents>{{long source text}}</documents>
<instructions>Using only the documents above, answer the question.</instructions>
<question>What changed between v1 and v2?</question>
Watch-outs. Anthropic notes exact formatting matters less as models get more capable — don’t over-engineer tag schemes. Keep tag names consistent throughout a prompt; mismatched names confuse rather than help.
4. Prompt caching: put stable content first — Critical (for cost/latency objectives)
Serves: Fewer calls (redundant compute), Speed, Tokens · Where: API, Agentic
How to use. Keep content you reuse across requests — system instructions, tool schemas, reference documents, long context — at the beginning of the prompt and among the first parameters in the request body, so it can be cached and reused. On Claude, mark cacheable spans with cache_control breakpoints; OpenAI applies caching automatically when prefixes match (Anthropic, Prompt caching; OpenAI, Prompt engineering). A useful complementary tactic is to maximize the shared prefix by pushing dynamic content (RAG results, history, user input) toward the end of the prompt — this keeps the cacheable portion stable across calls (OpenAI, Latency optimization).
Why it helps / impact. Reusing a cached prefix avoids reprocessing identical tokens on every turn. Anthropic’s cached input tokens are priced at 0.1× standard input tokens (~10%, i.e., up to ~90% savings on the cached portion), with cache writes costing 1.25× base (5-minute TTL) or 2× base (1-hour TTL) (Anthropic, Prompt caching). This is the strongest single lever for the cost/speed objectives in repeated-context workloads.
Example. A doc-Q&A bot caches a 50k-token manual once, then answers hundreds of user questions against the cached prefix at a fraction of the per-call cost.
Watch-outs. Caching only pays off with stable prefixes and repeated access within the cache lifetime (Anthropic’s standard minimum is ~5 minutes). It does nothing for unique-per-request context or low-volume use, and a changing prefix forces cache re-creation (extra write cost). It is an API-level technique — not directly controllable in the consumer chat UI.
5. Add context and motivation (the “why”) — High
Serves: Accuracy · Where: Chat, API
How to use. Explain why you want something, not just what. Anthropic notes the model can generalize from the explanation, producing more on-target results in cases your literal instructions didn’t cover (Anthropic, Prompting best practices).
Why it helps / impact. Motivation lets the model handle cases your instructions didn’t explicitly cover, instead of guessing. It reduces both off-target answers and clarification rounds.
Example. Instead of “Keep it under 200 words,” say “Keep it under 200 words — it’s going in a mobile push notification preview.” The model then makes sensible cuts you didn’t spell out.
Watch-outs. Keep the rationale short and high-signal; a paragraph of backstory is more tokens and more attention drain for marginal benefit.
6. Calibrate reasoning to task difficulty — High
Serves: Accuracy, Speed, Tokens · Where: Chat, API, Agentic
How to use. For genuinely multi-step problems, let the model reason before answering (step-by-step thinking, or a <thinking>/<answer> split when thinking is off). For modern reasoning models, do the opposite of older advice: keep instructions high-level and don’t add “think step by step” — they reason internally already. On Claude, prefer adaptive thinking (thinking: {type: "adaptive"}) plus an effort setting over hand-tuned budget_tokens; the model dynamically decides when and how much to think based on effort and query complexity, and Anthropic reports adaptive thinking reliably outperforms manual extended thinking in internal evaluations (Anthropic, Prompting best practices; OpenAI, Reasoning best practices).
Why it helps / impact. Reasoning markedly improves accuracy on math, logic, and complex coding. But on reasoning models it can backfire: redundant “think step by step” prompting adds latency and tokens for no gain, and excessive upfront exploration inflates thinking tokens and slows responses (Anthropic, Prompting best practices).
Example.
- Older / non-reasoning model: “Solve this logic puzzle. Think step by step, then give the answer.”
- Reasoning model: “Solve this logic puzzle.” (Let it reason on its own; reach for a lower
effort setting if it over-thinks.)
Watch-outs. Match the tactic to the model. Anthropic notes that with thinking disabled, some Claude models are sensitive to the word “think” — alternatives like “consider” or “reason through” can help. More reasoning ≠ always better: verbose chains cost tokens and time, and budget_tokens extended thinking is now deprecated on Claude 4.6 models — use effort or max_tokens instead.
7. Require self-checking / verification — High
Serves: Accuracy, Fewer calls · Where: Chat, API, Agentic
How to use. Append an explicit verification step, e.g., “Before finishing, check your answer against [criteria].” For code/agents, instruct the model to run tests or validate patches rather than trust a tool’s success message (Anthropic, Prompting best practices; OpenAI, Prompt engineering). The CorrectBench evaluation finds three useful design patterns work in practice — intrinsic (the model critiques its own output), external (a second model or tool checks), and fine-tuned — with mixing strategies giving further accuracy gains at an efficiency cost (Tie et al., 2025).
Why it helps / impact. Anthropic reports self-checking catches errors reliably, “especially for coding and math.” Catching a mistake inside one call avoids a second corrective round-trip (fewer calls). CorrectBench corroborates: self-correction methods improve accuracy “especially for complex reasoning tasks” (Tie et al., 2025).
Example. “Write the function, then write three test cases including one edge case, run them mentally, and fix any that fail before returning the final code.”
Watch-outs. Self-verification adds output tokens and latency, so reserve it for tasks where a wrong answer is costly. Two specific calibrations from CorrectBench: reasoning LLMs (e.g., DeepSeek-R1) get limited additional benefit from layered self-correction and incur high time costs, and a plain CoT baseline is often competitive on accuracy and efficiency — meaning a heavy verification scaffold isn’t always the right tradeoff (Tie et al., 2025). Self-verification is also not a substitute for real external tests in production.
8. Decompose, chain, and persist on complex tasks — High
Serves: Accuracy, Fewer calls · Where: API, Agentic, Chat
How to use. Break a complex request into ordered sub-tasks. For agents, instruct the model to resolve the full query before yielding — decomposing into sub-requests and confirming each is done — and to track progress (e.g., a TODO list). When you need to inspect or branch between stages, use explicit prompt chaining (separate calls), with the common pattern being draft → review against criteria → refine (OpenAI, Prompt engineering; Anthropic, Prompting best practices; Anthropic, Building effective agents).
Why it helps / impact. Decomposition raises accuracy on multi-part work and prevents the model from stopping after completing only part of the request — a frequent source of “I have to ask again” round-trips. Anthropic frames the broader pattern as choosing workflows (predictable code-orchestrated pipelines) when consistency matters versus agents (LLM-directed, dynamic) when flexibility matters, and starting with the simplest solution that works (Anthropic, Building effective agents).
Example. “First list the sub-questions this request contains. Then answer each in order. Finally, give a combined summary. Do not stop until all sub-questions are answered.”
Watch-outs. Capable models already handle much multi-step reasoning internally; over-prescribing rigid steps can hurt. Reserve explicit multi-call chaining for when you genuinely need to log, evaluate, or branch on intermediate output. Anthropic’s guidance: “consider adding complexity only when it demonstrably improves outcomes” (Anthropic, Building effective agents).
9. Engineer minimal, high-signal context and curate tools — High
Serves: Accuracy, Tokens · Where: Agentic, API
How to use. Aim for the smallest context that fully specifies the behavior — minimal does not necessarily mean short, but every token should earn its place. Pitch system prompts at the right level of abstraction: specific enough to guide behavior, general enough not to be brittle (neither hardcoded if-else logic nor vague hand-waving). Give agents a minimal viable tool set with non-overlapping, unambiguous tools (Anthropic, Effective context engineering for AI agents; Anthropic, Building effective agents).
Why it helps / impact. Because accuracy degrades as the window fills, trimming low-signal tokens directly protects accuracy and saves tokens. Anthropic’s test for tools: if a human engineer can’t say which tool applies in a situation, the agent can’t either — bloated tool sets cause wrong-tool errors. Anthropic also stresses that tool specifications deserve as much prompt-engineering attention as the main prompt — clear descriptions, example usage, and “Poka-yoke” parameter designs that prevent mistakes (e.g., requiring absolute filepaths) (Anthropic, Building effective agents).
Example. Replace three near-duplicate search tools with one well-described search(query, source) tool, and cut a 2,000-word system prompt of edge cases down to a few canonical rules plus examples.
Watch-outs. Over-trimming removes context the model genuinely needs. Anthropic’s recommended path: start minimal with the best model, then add instructions/examples only to fix observed failure modes.
10. Manage long-horizon context (compaction, notes, tool-result clearing, sub-agents) — High
Serves: Tokens, Fewer calls (redundant work), Accuracy (coherence) · Where: Agentic
How to use. For tasks that exceed a single context window, apply one or more of: compaction (summarize the conversation and restart with the summary); structured note-taking (persist progress/state to a file pulled back in later); tool-result clearing (drop raw outputs of already-used tool calls); and sub-agent architectures (delegate deep sub-tasks to agents with clean contexts that return only condensed summaries) (Anthropic, Effective context engineering for AI agents).
Why it helps / impact. These keep the working set small and high-signal across long runs, preserving coherence and avoiding re-derivation of state that was lost to context rot. Sub-agents in particular let a lead agent stay focused while each sub-agent’s heavy exploration (tens of thousands of tokens) collapses to a ~1–2k-token summary.
Example. A migration agent keeps a NOTES.md of decisions and a tests.json; when the window nears its limit it compacts, then continues from the notes instead of re-reading everything.
Watch-outs. Over-aggressive compaction can drop subtle details whose importance surfaces later — Anthropic advises tuning compaction prompts to maximize recall first, then trim. Sub-agents add orchestration complexity and can be over-used where a single direct call would do.
Serves: Speed, Fewer calls (round-trips) · Where: Agentic, API
How to use. When multiple tool calls are independent (no call depends on another’s output), issue them simultaneously rather than sequentially. Claude’s recent models do this well by default and can be pushed toward ~100% reliability with a short instruction; never use placeholders for parameters you don’t yet have (Anthropic, Prompting best practices).
Why it helps / impact. Parallelizing independent reads/searches collapses many sequential round-trips into one wall-clock step — a direct speed win for agentic workflows.
Example. “When reading 3 files with no dependencies between them, make all 3 read calls in parallel.”
Watch-outs. Only parallelize truly independent calls — dependent calls (where one’s output feeds another’s parameters) must stay sequential. Anthropic notes aggressive parallel bash execution can even bottleneck the host system.
12. Reduce latency through model selection, output length, and streaming — High
Serves: Speed, Tokens · Where: Chat, API, Agentic
How to use. Engineer for accuracy first, then attack latency on three levers in this order. (1) Choose the right model. Smaller models are faster and cheaper; on Claude, Claude Haiku 4.5 is the speed-tier choice (Anthropic, Reducing latency). OpenAI frames the same trade: small/mini/nano models for speed, larger models when accuracy demands it (OpenAI, Latency optimization). (2) Generate fewer tokens. Cap max_tokens, ask for sentence- or paragraph-bounded responses (not word counts — token-vs-word mismatch makes word limits unreliable), and shorten structured-output field names. (3) Stream the response. Streaming returns the first tokens as soon as they’re generated, dramatically improving perceived responsiveness.
Why it helps / impact. Generation is almost always the highest-latency step, so output cuts dominate: OpenAI’s heuristic is that cutting ~50% of output tokens cuts ~50% of latency, while cutting ~50% of input tokens cuts only ~1–5% — unless you’re working with truly massive contexts, spend effort on the output, not the input (OpenAI, Latency optimization). Streaming is described by OpenAI as “the single most effective approach” for cutting waiting time. Other levers worth knowing: combine sequential LLM calls into one prompt to skip round-trips, parallelize independent steps (see Tactic 11), and “don’t default to an LLM” when a hard-coded or pre-computed answer would do (OpenAI, Latency optimization).
Example. A customer-service triage bot moves intent classification from a large model to a smaller fine-tuned model, drops verbose JSON field names (“number_of_messages_in_conversation_so_far” → “n_msg”), and streams the response — yielding both faster perceived response and lower spend per call (OpenAI, Latency optimization, customer-service example).
Watch-outs. Don’t optimize latency before you’ve got accuracy where you need it — Anthropic explicitly warns that premature latency optimization can prevent you from discovering what top performance looks like (Anthropic, Reducing latency). max_tokens is a blunt cutoff that can truncate mid-sentence, so use it for short answers or pair it with parsing logic. Small models may need stronger prompting (more detailed instructions, more few-shot examples) to maintain quality on harder tasks (OpenAI, Latency optimization).
13. Ground answers and permit “I don’t know” — High
Serves: Accuracy · Where: Chat, API, Agentic
How to use. Explicitly allow the model to say it doesn’t know, and require it to base claims on provided/inspected material. Anthropic’s hallucination-reduction guide adds two more concrete techniques: for long documents (>20k tokens), have the model extract verbatim quotes first before reasoning, and require citations so each claim is auditable — retract any claim it cannot support with a quote (Anthropic, Reduce hallucinations). An empirical refinement of this same idea is Highlighted Chain of Thought (HoT), which wraps key facts from the input in XML tags and then grounds each response fact back to a tag; tested across 5 LLMs and 20 tasks, HoT cut the SelfCheckGPT hallucination rate from 21.22% to 14.92% and improved CoT accuracy by roughly +2.0 to +2.6 percentage points across arithmetic, QA, logical reasoning, and long-context tasks (Nguyen et al., 2025). For coding agents, instruct the model to read the referenced file before answering and never speculate about code it hasn’t opened (Anthropic, Prompting best practices).
Why it helps / impact. This is a primary hallucination-reduction lever, which is core to accuracy and trust — particularly in RAG and codebase Q&A. A grounded “I don’t know” is more useful than a confident fabrication that triggers downstream rework.
Example. “Answer using only the documents above. If they don’t contain the answer, say ‘Not found in the provided sources.’”
Watch-outs. Anthropic notes these techniques “significantly reduce hallucinations” but “don’t eliminate them entirely” (Anthropic, Reduce hallucinations). Empirical work confirms this: even with accurate and relevant retrieved content, RAG models can still produce hallucinations that conflict with the retrieved text — supplying context is necessary but not sufficient for groundedness (Sun et al., ICLR 2025). Validate critical claims for high-stakes use. Also, an over-cautious “I don’t know” instruction can make the model decline answerable questions; pair it with the instruction to answer when the source does support it.
14. Assign a clear role / persona — Medium
Serves: Accuracy (tone/domain framing) · Where: Chat, API
How to use. Set a role in the system/developer message — even one sentence focuses behavior and tone (e.g., “You are a senior Python code reviewer”). OpenAI’s “Identity” section serves the same purpose (Anthropic, Prompting best practices; OpenAI, Prompt engineering).
Why it helps / impact. A role primes domain-appropriate vocabulary, depth, and tone, nudging outputs toward the right register. Impact is real but secondary to clear instructions and examples — a good role with vague instructions still underperforms.
Example. System: “You are a careful technical editor. Preserve the author’s voice; fix only grammar and clarity.”
Watch-outs. A role is not a substitute for explicit instructions; it shapes how the model responds, not what task to do. Overly theatrical personas can reduce precision.
Serves: Accuracy (consistency), Fewer calls · Where: API, Chat
How to use. State the exact format you need; for machine-consumed output, request JSON conforming to a schema. Both providers offer dedicated Structured Outputs features that guarantee schema conformance — prefer these over prompt-only tricks when you need parseable output, and tell the model what to do rather than what to avoid (Anthropic, Increase output consistency; OpenAI, Prompt engineering / Structured Outputs).
Why it helps / impact. Predictable structure makes output reliably parseable, cutting the failed-parse retries that quietly inflate call counts and cost in pipelines. The historical concern that strict formats hurt accuracy appears to be largely model-dependent: a recent causal-inference analysis across JSON, XML, YAML and unstructured formats on GPT-4o found no causal effect of format on output quality in 43 of 48 scenarios, and reasoning models (OpenAI o3) were more resilient still — meaning modern strong models can usually meet format constraints without measurable accuracy loss (Yuan et al., 2025). Note that this finding contrasts with earlier (pre-2025) reports of format-driven degradation, so the calibration depends on your model class.
Example. “Return only valid JSON: {\"endpoint\": string, \"method\": string, \"auth_required\": boolean}. No prose, no code fences.”
Watch-outs. Heavy formatting demands can occasionally crowd out reasoning quality on weaker models; for hard reasoning tasks on a non-reasoning model, let the model reason first and format last. Match prompt style to desired output — e.g., a Markdown-free prompt tends to yield less Markdown. Note that prefilled responses on the last assistant turn are no longer supported on Claude 4.6 and later models — migrate any prefill-based formatting tricks to Structured Outputs or in-prompt format specification (Anthropic, Prompting best practices; Anthropic, Increase output consistency).
16. Use positive framing (say what to do, not what not to do) — Low
Serves: Accuracy (formatting), output style · Where: Chat, API
How to use. Convert prohibitions into positive instructions that name the target behavior. For instance, rather than telling the model not to use Markdown, tell it to write in plain, flowing paragraphs (Anthropic, Prompting best practices).
Why it helps / impact. Positive instructions give the model a concrete target to hit, which it follows more reliably than a negative constraint. A useful refinement, not a make-or-break lever.
Example. Replace “Don’t be verbose” with “Answer in at most 3 sentences.”
Watch-outs. Some constraints are inherently negative (safety, exclusions) and must stay explicit. Low standalone impact — it amplifies Tactic 1 rather than replacing it.
17. Use concise-reasoning styles (Chain-of-Draft) for speed/cost — Low
Serves: Tokens, Speed · Where: API, Chat
How to use. When you want the accuracy benefit of step-by-step reasoning without the token cost, prompt for terse intermediate steps instead of verbose prose — the “Chain-of-Draft” idea of minimal, dense reasoning notes (Xu et al., Chain of Draft, 2025). This aligns with Anthropic’s guidance to constrain over-long thinking.
Why it helps / impact. In the original study, Chain-of-Draft reportedly held accuracy roughly even with standard Chain-of-Thought while consuming only about 7.6% of the tokens on mathematical reasoning, lowering cost and latency on those tasks (Xu et al., 2025). Rated Low overall because its accuracy effect is roughly neutral — its value is efficiency, not correctness.
Example. “Reason in short shorthand steps (≤5 words each), then give the final answer on its own line.”
Watch-outs. The token-reduction magnitude is highly domain-dependent. A direct replication on SWE-bench (software engineering, 300 samples) found baseline CoD used 55.4% of CoT’s tokens — not 7.6% — while retaining >90% of CoT’s code quality (Yang, 2025). Context-heavy, precision-critical domains require more intermediate work, so the math-reasoning gains don’t transfer wholesale. Aggressive brevity can hurt on tasks that genuinely need detailed intermediate work, and on built-in reasoning models you should prefer the model’s own effort/thinking controls over hand-crafted concise-reasoning prompts.
Sources
Primary sources (official documentation, engineering writing, and peer-reviewed or empirical research). Per the agreed scope, evergreen official docs are included even where not dated within the last 6 months; Anthropic docs reflect current models (through Claude Opus 4.8), and the prompt-caching page was current as of June 2026.
Official documentation and engineering writing
-
Anthropic — Prompting best practices (Claude API Docs; evergreen, current models). https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices — clarity, examples, XML structuring, roles, long-context ordering, adaptive thinking & effort, tool use & parallel calls, agentic systems, hallucination reduction in coding, self-checking, formatting, prefill deprecation on Claude 4.6+.
-
Anthropic — Effective context engineering for AI agents (Engineering blog; published Sep 29, 2025). https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents — context as finite resource, context rot, minimal high-signal tokens, system-prompt altitude, tool curation, just-in-time retrieval, compaction, structured note-taking, sub-agents.
-
Anthropic — Prompt caching (Claude API Docs; current as of June 2026). https://platform.claude.com/docs/en/build-with-claude/prompt-caching — caching mechanics, cache_control, pricing multipliers (read 0.1×, 5-min write 1.25×, 1-hour write 2×), cache lifetimes, ideal use cases.
-
Anthropic — Building effective agents (Anthropic Research; published Dec 19, 2024). https://www.anthropic.com/research/building-effective-agents — workflow vs. agent distinction, prompt chaining / routing / parallelization / orchestrator-workers / evaluator-optimizer patterns, “simplest solution that works,” tool-engineering best practices and agent-computer interface guidance.
-
Anthropic — Reduce hallucinations (Claude API Docs). https://platform.claude.com/docs/en/test-and-evaluate/strengthen-guardrails/reduce-hallucinations — allow “I don’t know,” verbatim-quote grounding for long docs, citation verification, CoT verification, Best-of-N, iterative refinement, external-knowledge restriction.
-
Anthropic — Increase output consistency (Claude API Docs). https://platform.claude.com/docs/en/test-and-evaluate/strengthen-guardrails/increase-consistency — Structured Outputs for guaranteed schema conformance, format specification (JSON/XML/templates), constrain with examples, retrieval, chain prompts, role consistency, prefill deprecation notice.
-
Anthropic — Reducing latency (Claude API Docs). https://platform.claude.com/docs/en/test-and-evaluate/strengthen-guardrails/reduce-latency — engineer for accuracy first, then model selection (Claude Haiku 4.5 for speed), prompt and output length, sentence/paragraph limits over word counts, max_tokens, temperature, streaming.
-
OpenAI — Prompt engineering (OpenAI API Docs). https://developers.openai.com/api/docs/guides/prompt-engineering — message roles and instruction hierarchy (Identity → Instructions → Examples → Context ordering), Markdown/XML structure, few-shot, RAG-style context inclusion, prompt-caching placement (stable content first, among first API parameters), GPT-5 / reasoning prompting, evals and snapshot pinning, agentic planning/persistence.
-
OpenAI — Reasoning best practices (OpenAI API Docs). https://developers.openai.com/api/docs/guides/reasoning-best-practices — keep prompts simple, avoid explicit chain-of-thought on reasoning models, use delimiters, try zero-shot before few-shot, developer messages.
-
OpenAI — Optimizing LLM accuracy (OpenAI API Docs). https://developers.openai.com/api/docs/guides/optimizing-llm-accuracy — optimization matrix (context vs. behavior axes), prompt engineering first, in-context vs. learned memory framing, RAG and fine-tuning trade-offs; quantified Icelandic-correction case (zero-shot BLEU 62 → few-shot 70 → FT GPT-4 87 → FT+RAG 83).
-
OpenAI — Latency optimization (OpenAI API Docs). https://developers.openai.com/api/docs/guides/latency-optimization — seven principles (process tokens faster, generate fewer tokens, use fewer input tokens, make fewer requests, parallelize, make users wait less, don’t default to an LLM); quantified heuristics (~50%-output ≈ ~50%-latency; ~50%-input ≈ ~1–5% latency); streaming as “the single most effective approach.”
Peer-reviewed and empirical research
-
Xu, Xie, Zhao, He — “Chain of Draft: Thinking Faster by Writing Less” (arXiv:2502.18600; Feb 2025). https://arxiv.org/abs/2502.18600 — concise intermediate reasoning matching/surpassing CoT accuracy at ~7.6% of the tokens on mathematical reasoning tasks. Origin paper for the concise-reasoning tactic.
-
Nguyen, Bolton, Taesiri, Nguyen — “HoT: Highlighted Chain of Thought for Referencing Supporting Facts from Inputs” (arXiv:2503.02003; Mar 2025). https://arxiv.org/abs/2503.02003 — wrapping in-question key facts in XML tags and grounding response facts back to them; tested across 5 LLMs and 20 tasks. Reduces hallucination rate (SelfCheckGPT) from 21.22% to 14.92% and improves CoT accuracy by +2.10 / +2.58 / +2.53 / +2.03 pp on arithmetic / QA / logical reasoning / long-context tasks.
-
Yang — “Chain of Draft for Software Engineering: Challenges in Applying Concise Reasoning to Code Tasks” (arXiv:2506.10987; Jun 2025). https://arxiv.org/abs/2506.10987 — direct cross-domain replication of Chain of Draft on SWE-bench (300 samples). Baseline CoD used 55.4% of CoT’s tokens (vs. 7.6% on math) while retaining >90% of CoT’s code quality — efficiency gains are strongly domain-dependent.
-
Song, Zheng, Luo, Pan — “Can Many-Shot In-Context Learning Help LLMs as Evaluators? A Preliminary Empirical Study” (arXiv:2406.11629; COLING 2025). https://arxiv.org/abs/2406.11629 — many-shot ICL outperforms zero- and few-shot regimes when GPT-4o is used as an evaluator; many-shot with model-generated evaluation rationales (MSwR format) outperforms many-shot without references (MSoR).
-
Yi, Zeng, Ling, Luo, Xu, Liu, Luan, Cao, Shen — “Attention Basin: Why Contextual Position Matters in Large Language Models” (arXiv:2508.05128; Aug 2025). https://arxiv.org/abs/2508.05128 — across 10 LLMs, attention to structured items (retrieved documents or few-shot examples) systematically peaks at beginning and end and drops in the middle; reordering critical content to high-attention positions yields substantial gains on multi-hop QA and few-shot ICL. Provides mechanistic backing for the long-documents-at-top / query-at-end ordering recommendation and for example-position effects.
-
Tie, Yuan, Zhao, Hu, Gu, Zhang, Zhang, Wu, Tu, Jin, Wen, Chen, Zhou, Sun — “Can LLMs Correct Themselves? A Benchmark of Self-Correction in LLMs (CorrectBench)” (arXiv:2510.16062; Oct 2025). https://arxiv.org/abs/2510.16062 — benchmark of intrinsic, external, and fine-tuned self-correction across commonsense reasoning, math, and code generation. Self-correction improves accuracy especially on complex reasoning; mixing strategies improves further but reduces efficiency; reasoning LLMs (e.g., DeepSeek-R1) gain less and incur high time costs; a plain CoT baseline is often competitive on both accuracy and efficiency.
-
Yuan, Zhao, Zhang, Luo, Ma — “Quantifying the Impact of Structured Output Format on Large Language Models through Causal Inference” (arXiv:2509.21791; Sep 2025; American Express). https://arxiv.org/abs/2509.21791 — across seven public and one developed reasoning task, causal-inference analysis finds no causal impact of JSON / XML / YAML versus unstructured output on GPT-4o generation quality in 43 of 48 scenarios; the rare effects depend on specific instruction framing; OpenAI o3 is more resilient to output formats than GPT-4o / GPT-4.1.
-
Sun, Zang, Zheng, Xu, Zhang, Yu, Song, Li — “ReDeEP: Detecting Hallucination in Retrieval-Augmented Generation via Mechanistic Interpretability” (ICLR 2025 Spotlight; arXiv:2410.11414). https://arxiv.org/abs/2410.11414 — even when retrieved content is accurate and relevant, RAG models can still produce hallucinations that conflict with the retrieved text; grounding is necessary but not sufficient for full hallucination elimination.
Note on scope: a recent broad prompting survey published in 2025+ with strong empirical meta-findings (i.e., aggregated replications of which techniques work) was sought but not identified. The Prompt Report (Schulhoff et al., 2024) and Sahoo et al. (2024, revised 2025) provide taxonomies but not the empirical synthesis this guide would cite. The individual peer-reviewed and empirical papers above (sources 12–19) are the strongest available evidence within scope.
Compiled to the agreed scope: tactics span chat, API, and agentic use, each tagged by objective served and applicable context. Rankings are directional judgments weighted toward accuracy, as specified. Examples are original illustrations created for this guide; all other claims are drawn from the sources above.
