Engineering Prompts

Systematically design prompts using proven patterns instead of trial-and-error iteration, to achieve reliable outputs and reduce cost.

Need structured JSON?        → JSON mode / tool calling
Complex reasoning?           → Chain-of-thought ("think step by step")
Specific format/style?       → Few-shot (2-5 examples)
Knowledge from documents?    → RAG
Multi-step workflow?         → Prompt chaining
Agent using tools?           → Tool use / ReAct
Simple, well-defined task?   → Zero-shot

Zero-shot: Clear imperative instruction + input + output format. Use for simple, well-defined tasks.

Python
prompt = """Summarize the following review in 2 sentences, focusing on key concerns:
Review: {text}
Summary:"""

Few-shot: Task description + 2-5 diverse examples + actual task. Quality over quantity; randomize example order to avoid position bias; explicitly label edge cases.

Python
prompt = """Classify sentiment.
Review: "Absolutely fantastic!" → Sentiment: positive
Review: "Waste of time." → Sentiment: negative
Review: "It was okay." → Sentiment: neutral
Review: "{new_review}" → Sentiment:"""

Chain-of-thought: Add "Let's think step by step" for zero-shot CoT, or provide worked examples showing reasoning for few-shot CoT. Use for math, logic, multi-hop reasoning. Yields 20-50% accuracy gains on reasoning benchmarks (Wei et al. 2022).

Structured output: Prefer native JSON mode or tool/function calling over asking the model to "output JSON" in free text — avoids parsing failures.

Python
# Anthropic tool use for structured extraction
tools = [{
    "name": "record_data",
    "description": "Record structured user information",
    "input_schema": {
        "type": "object",
        "properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
        "required": ["name", "age"]
    }
}]

System prompts/personas: Structure as Role → Capabilities → Behavior guidelines → Output format → Safety boundaries. Keep under 1000 tokens. Version control like code. Claude responds well to XML tags (<capabilities>, <guidelines>).

Tool use: Write specific, actionable tool descriptions — vague descriptions cause the model to misuse or ignore tools.

Python
# BAD: "description": "Search for stuff"
# GOOD: "description": "Search knowledge base for product docs. Use when user asks about features or troubleshooting. Returns top 5 articles."

Prompt chaining: Break complex tasks into sequential prompts (output of step N feeds step N+1). Improves debuggability and enables prompt caching for cost reduction (Anthropic cache_control: ephemeral gives ~90% cost reduction on repeated large context).

• Set temperature=0 for deterministic/structured tasks; raise it only for creative generation.
• Use native structured-output features (JSON mode, tool calling, Zod/Pydantic schemas) instead of parsing free text.
• Version prompts like code; track changes and rationale.
• Log token usage and cost per call; monitor for regressions.
• Wrap LLM calls with retry logic (exponential backoff) for rate limits/transient errors.
• Sanitize user input to guard against prompt injection (e.g., reject "ignore previous instructions" patterns, keep user content clearly delimited from instructions).
• Write automated test cases (expected-contains / should-not-contain assertions) before shipping prompt changes.
• Match style to provider: Claude favors XML structure and detailed instructions; GPT-4 favors concise system messages; open-source models (Llama) need more explicit instructions and benefit heavily from few-shot examples.

• Vague instructions ("Analyze this data") instead of specific, structured asks ("Identify top 3 products, growth trends, anomalies; present as table").
• Interpolating raw user input directly into prompts without delimiting it from system instructions — opens injection risk.
• Asking the model to "output valid JSON" in prose instead of using JSON mode/tool calling — causes brittle parsing.
• Using few-shot examples that are too similar (no diversity) or too many (diminishing returns beyond ~5).
• Not setting temperature=0 for tasks requiring reproducibility.
• Copy-pasting the same prompt across model providers without adjusting style — Claude/GPT/Gemini/Llama respond differently to structure and verbosity.
• Skipping intermediate output inspection in prompt chains, making failures hard to debug.
• Ignoring cost: not leveraging prompt caching for large repeated context, or not monitoring token usage in production.