Prompt Engineering

What is Prompt Engineering?

Prompt engineering is the practice of designing, structuring, and iterating on inputs to a large language model (LLM) to achieve reliable, high-quality outputs for a given task. Unlike traditional software, LLMs have no formal API for features — the prompt is the interface.

A prompt encodes task description, context, constraints, and examples in natural language. The model then "reads" the prompt and its statistical training to produce a completion. The better the prompt, the more the model's latent knowledge is surfaced in a useful form.

Why It Matters

Zero-Shot Prompting

Zero-shot prompting asks the model to perform a task without any examples — relying entirely on the model's pre-trained knowledge and the clarity of the instruction.

When It Works

Zero-shot is effective for tasks the model has seen extensively during training, for simple transformations (classify, summarise, translate), and when the task is well-specified by the instruction alone.

Best Practices

Few-Shot Prompting

Few-shot prompting provides worked examples of the desired input-output mapping before presenting the actual task. The model uses these as a template, inferring the pattern from the demonstrations.

How Many Examples?

Example Format Matters

The structure you use in your examples will be mimicked. Consistent delimiters (like Q: / A:, XML tags, or JSON templates) help the model identify the pattern. Inconsistent formatting across examples confuses the model.

Diversity of Examples

Choose examples that cover the distribution of real inputs — including edge cases. If all your examples are easy positives, the model will struggle on negatives and ambiguous cases. Balanced, diverse examples produce more robust prompts.

Chain-of-Thought (CoT) Prompting

Chain-of-Thought prompting encourages the model to produce intermediate reasoning steps before giving a final answer. This dramatically improves performance on tasks requiring arithmetic, logical inference, symbolic manipulation, or multi-step problem solving.

Zero-Shot CoT

Simply appending the magic phrase "Let's think step by step." to a question (Wei et al., 2022) elicits chain-of-thought reasoning without any examples. Surprisingly effective for arithmetic and logical tasks.

Few-Shot CoT

Provide worked examples where the reasoning process is shown, not just the final answer. The model learns to decompose the problem the same way. This is more powerful than zero-shot CoT but requires crafted examples.

Self-Consistency

Tree of Thought (ToT)

Tree of Thought (Yao et al., 2023) extends CoT by allowing the model to explore multiple branching reasoning paths simultaneously, evaluate intermediate states, and backtrack — mimicking deliberate human problem-solving rather than greedy left-to-right generation.

System Prompts

In chat-based APIs, the system prompt is a privileged instruction block that precedes the conversation. It sets the model's persona, scope, tone, and output format — and is typically hidden from end users.

What System Prompts Control

Effective System Prompt Patterns

Advanced Techniques

Prompt Anti-patterns

Knowing what not to do is as important as knowing best practices. These common mistakes reliably degrade output quality or create security vulnerabilities.

Code Example — Prompt Patterns with the Anthropic SDK

import anthropic
import json

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from env

# ── 1. Few-Shot Classification ────────────────────────────────────────
def classify_sentiment(text: str) -> str:
    message = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=64,
        system="You are a sentiment classifier. Reply with exactly one word: positive, negative, or neutral.",
        messages=[
            {"role": "user", "content": "Text: 'The product is amazing!'\nSentiment:"},
            {"role": "assistant", "content": "positive"},
            {"role": "user", "content": "Text: 'Terrible experience, never again.'\nSentiment:"},
            {"role": "assistant", "content": "negative"},
            {"role": "user", "content": "Text: 'Delivery was on time.'\nSentiment:"},
            {"role": "assistant", "content": "neutral"},
            {"role": "user", "content": f"Text: '{text}'\nSentiment:"},
        ],
    )
    return message.content[0].text.strip()

print(classify_sentiment("I waited 3 weeks but the quality was worth it."))
# → positive


# ── 2. Chain-of-Thought Math Reasoning ───────────────────────────────
def solve_with_cot(problem: str) -> str:
    message = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=512,
        system=(
            "You are a maths tutor. "
            "Think step by step inside <thinking> tags, "
            "then give the final numeric answer inside <answer> tags."
        ),
        messages=[{"role": "user", "content": problem}],
    )
    return message.content[0].text

result = solve_with_cot(
    "A train travels 120 km at 60 km/h, then 80 km at 40 km/h. "
    "What is the average speed for the whole journey?"
)
print(result)
# <thinking> Time for leg 1: 120/60 = 2 h. Time for leg 2: 80/40 = 2 h.
# Total distance: 200 km. Total time: 4 h. Avg speed: 200/4 = 50 km/h </thinking>
# <answer>50 km/h</answer>


# ── 3. Structured JSON Output ─────────────────────────────────────────
def extract_entities(text: str) -> dict:
    message = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=256,
        system=(
            "Extract named entities from the text. "
            "Return ONLY valid JSON matching this schema: "
            '{"people": [], "organisations": [], "locations": []}. '
            "No prose, no markdown fences."
        ),
        messages=[{"role": "user", "content": text}],
    )
    return json.loads(message.content[0].text)

entities = extract_entities(
    "Elon Musk announced that Tesla will open a new factory in Berlin."
)
print(entities)
# → {'people': ['Elon Musk'], 'organisations': ['Tesla'], 'locations': ['Berlin']}

Related Topics