Prompt Engineering: Zero-Shot, Few-Shot, and Chain-of-Thought

The Story That Explains Prompt Engineering

Prompt Engineering is the discipline of designing, structuring, and refining inputs (prompts) to get the best possible output from a Large Language Model (LLM). It is part art, part science, and entirely learnable.

The Anatomy of a Great Prompt

Before diving into techniques, you need to understand what a prompt actually contains. Most powerful prompts share the same building blocks:

Technique 1 — Zero-Shot Prompting

Zero-Shot Prompting means you give the model a task directly — no demonstrations, no examples. The model is expected to draw entirely on its pre-trained knowledge.

Zero-Shot: Basic Examples

Zero-Shot Code Example — Sentiment Classifier

import anthropic

client = anthropic.Anthropic()

def classify_sentiment_zero_shot(text: str) -> str:
    """Zero-shot sentiment classification — no examples given."""
    prompt = (
        f"Classify the sentiment of the following customer review as exactly "
        f"one of: POSITIVE, NEGATIVE, or NEUTRAL. "
        f"Output ONLY the label — no explanation, no punctuation.\n\n"
        f"Review: {text}"
    )
    message = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=10,
        messages=[{"role": "user", "content": prompt}]
    )
    return message.content[0].text.strip()

# Test it
reviews = [
    "The battery died after 2 days. Terrible product.",
    "Absolutely love this! Best purchase I've made all year.",
    "It arrived on Tuesday. The box was blue."
]

for review in reviews:
    result = classify_sentiment_zero_shot(review)
    print(f"Sentiment: {result:10s} | Review: {review[:50]}...")

Technique 2 — Few-Shot Prompting

Few-Shot Prompting means providing 2–10 input/output examples before your actual task. The model learns the desired format, style, and reasoning pattern from those examples and applies the same pattern to the final input.

Few-Shot: The Anatomy of a Shot

Few-Shot: Visual Diagram

Few-Shot Code Example — Custom Entity Extractor

import anthropic
import json

client = anthropic.Anthropic()

def extract_entities_few_shot(text: str) -> dict:
    """
    Few-shot entity extraction.
    Returns JSON with keys: person, organisation, location, amount.
    """
    few_shot_prompt = """Extract entities from financial news. 
Return ONLY a JSON object with keys: person, organisation, location, amount.
If a key is not present, use null.

---
Input: "Sundar Pichai announced Google will invest $1.2 billion in its Dublin campus."
Output: {"person": "Sundar Pichai", "organisation": "Google", "location": "Dublin", "amount": "$1.2 billion"}

---
Input: "The Reserve Bank of India raised interest rates by 0.25%."
Output: {"person": null, "organisation": "Reserve Bank of India", "location": "India", "amount": "0.25%"}

---
Input: "Elon Musk's X Corp faced regulatory scrutiny in Brussels last month."
Output: {"person": "Elon Musk", "organisation": "X Corp", "location": "Brussels", "amount": null}

---
Input: """ + text + """
Output:"""

    message = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=200,
        messages=[{"role": "user", "content": few_shot_prompt}]
    )
    raw = message.content[0].text.strip()
    return json.loads(raw)

# Test
test = "Mukesh Ambani's Reliance Industries secured a ₹5,000 crore deal in Mumbai."
result = extract_entities_few_shot(test)
print(json.dumps(result, indent=2))

How Many Shots Do You Need?

Technique 3 — Chain-of-Thought (CoT) Prompting

Chain-of-Thought (CoT) Prompting — introduced by Wei et al. (2022) at Google — instructs the model to reason through a problem step-by-step before giving the final answer. The reasoning chain itself becomes part of the context, and each step acts as a scaffold for the next.

Three Forms of Chain-of-Thought

Chain-of-Thought: Visual Comparison

CoT Code Example — Multi-Step Reasoning with Structured Output

import anthropic
import re

client = anthropic.Anthropic()

def solve_with_cot(problem: str) -> dict:
    """
    Chain-of-Thought solver.
    Forces the model to reason step-by-step, then extract the final answer.
    Returns: {"reasoning": str, "answer": str}
    """
    prompt = f"""You are a careful analytical reasoner.
Solve the problem below step-by-step.

Rules:
1. Show every calculation or logical step.
2. Label each step clearly: Step 1, Step 2, etc.
3. At the very end, write exactly: FINAL ANSWER: 

Problem: {problem}

Let's think step by step."""

    message = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=800,
        messages=[{"role": "user", "content": prompt}]
    )

    full_response = message.content[0].text
    # Parse out reasoning and final answer
    match = re.search(r"FINAL ANSWER:\s*(.+)", full_response, re.IGNORECASE)
    final_answer = match.group(1).strip() if match else "Not found"

    return {
        "reasoning": full_response,
        "answer": final_answer
    }

# Test with a word problem
problem = """A shopkeeper sells apples at ₹12 each and oranges at ₹8 each.
If a customer buys 5 apples and 7 oranges and pays ₹100,
how much change does the customer receive?"""

result = solve_with_cot(problem)
print("=== REASONING ===")
print(result["reasoning"])
print("\n=== FINAL ANSWER ===")
print(result["answer"])

Few-Shot CoT — The Combination That Dominates

Few-Shot CoT combines both techniques: you provide 2–3 examples where each example shows a full reasoning chain, not just an answer. This teaches the model both what to produce (format) and how to think (reasoning style).

Few-Shot CoT: Full Code Example — Medical Triage Classifier

import anthropic

client = anthropic.Anthropic()

FEW_SHOT_COT_SYSTEM = """You are a clinical triage assistant.
For each patient description, reason through the symptoms step-by-step,
then assign exactly one triage level: CRITICAL, URGENT, or STANDARD.

Format your response as:
Reasoning: 
Triage: """

FEW_SHOT_EXAMPLES = [
    {
        "role": "user",
        "content": "Patient: 58-year-old male. Sudden severe chest pain radiating to left arm. Profuse sweating. Onset 20 minutes ago."
    },
    {
        "role": "assistant",
        "content": """Reasoning:
Step 1: Sudden severe chest pain in a 58yo male is a cardiac red flag.
Step 2: Radiation to the left arm strongly suggests myocardial involvement.
Step 3: Diaphoresis (profuse sweating) indicates sympathetic response — consistent with acute MI.
Step 4: 20-minute onset means active event, not resolved episode.
Conclusion: Classic STEMI presentation. Every minute counts for myocardial salvage.
Triage: CRITICAL"""
    },
    {
        "role": "user",
        "content": "Patient: 24-year-old female. Persistent headache for 2 days. No fever. No vomiting. No vision changes. Responsive and oriented."
    },
    {
        "role": "assistant",
        "content": """Reasoning:
Step 1: Persistent headache for 2 days — duration warrants attention but not emergency.
Step 2: No fever rules out meningitis/encephalitis as immediate concern.
Step 3: No vomiting or vision changes — no raised ICP indicators.
Step 4: Patient is alert and oriented — no neurological compromise.
Conclusion: Tension or migraine-type headache most likely. Needs evaluation, not emergency bypass.
Triage: URGENT"""
    }
]

def triage_patient(description: str) -> str:
    messages = FEW_SHOT_EXAMPLES + [
        {"role": "user", "content": description}
    ]
    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=400,
        system=FEW_SHOT_COT_SYSTEM,
        messages=messages
    )
    return response.content[0].text

# New patient
new_patient = "Patient: 6-year-old child. Mild cough and runny nose for 3 days. Playing normally. No difficulty breathing. Temp: 37.8°C."
print(triage_patient(new_patient))

Advanced CoT Variants

Self-Consistency CoT — Code Example

import anthropic
from collections import Counter
import re

client = anthropic.Anthropic()

def self_consistency_cot(problem: str, n_samples: int = 5) -> dict:
    """
    Self-Consistency CoT:
    Generate n reasoning chains, extract final answers, return majority vote.
    """
    prompt = f"""Solve this maths problem step by step.
At the end, write: ANSWER: 

Problem: {problem}

Let's think step by step."""

    answers = []
    reasoning_chains = []

    for i in range(n_samples):
        response = client.messages.create(
            model="claude-opus-4-5",
            max_tokens=500,
            temperature=0.7,   # Temperature > 0 for diverse chains
            messages=[{"role": "user", "content": prompt}]
        )
        text = response.content[0].text
        reasoning_chains.append(text)

        match = re.search(r"ANSWER:\s*([\d.,]+)", text)
        if match:
            answers.append(match.group(1).strip())

    # Majority vote
    vote_counts = Counter(answers)
    majority_answer = vote_counts.most_common(1)[0][0] if answers else "No answer"

    return {
        "all_answers": answers,
        "vote_distribution": dict(vote_counts),
        "final_answer": majority_answer,
        "confidence": vote_counts[majority_answer] / n_samples if answers else 0.0
    }

problem = "A tank fills in 6 hours. A drain empties it in 9 hours. If both are open, how many hours to fill an empty tank?"
result = self_consistency_cot(problem, n_samples=5)
print(f"All answers:       {result['all_answers']}")
print(f"Vote distribution: {result['vote_distribution']}")
print(f"Final answer:      {result['final_answer']}")
print(f"Confidence:        {result['confidence']:.0%}")

Comparing All Three Techniques

Prompt Engineering in the Wild — Full Pipeline

Here is a complete, production-grade prompt engineering pipeline that automatically selects the best technique for a given task type:

import anthropic
from enum import Enum
from dataclasses import dataclass
from typing import Optional

client = anthropic.Anthropic()

class TaskType(Enum):
    CLASSIFICATION = "classification"
    REASONING      = "reasoning"
    EXTRACTION     = "extraction"
    GENERATION     = "generation"

@dataclass
class PromptConfig:
    task_type:   TaskType
    user_input:  str
    system_role: str            = "You are a helpful AI assistant."
    examples:    list           = None
    use_cot:     bool           = False
    output_fmt:  Optional[str]  = None

def build_prompt(config: PromptConfig) -> str:
    """Build the optimal prompt for the given config."""
    parts = []

    if config.output_fmt:
        parts.append(f"Output format: {config.output_fmt}\n")

    # Inject few-shot examples if provided
    if config.examples:
        parts.append("Examples:\n")
        for i, ex in enumerate(config.examples, 1):
            parts.append(f"Example {i}:\nInput: {ex['input']}\nOutput: {ex['output']}\n---")
        parts.append("")

    parts.append(f"Input: {config.user_input}")

    if config.use_cot:
        parts.append("\nLet's think step by step.")

    return "\n".join(parts)

def run_pipeline(config: PromptConfig) -> str:
    prompt = build_prompt(config)
    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=600,
        system=config.system_role,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.content[0].text

# ── Example 1: Few-Shot Classification ───────────────────────
classification_config = PromptConfig(
    task_type=TaskType.CLASSIFICATION,
    system_role="You are a financial sentiment classifier. Output one label only.",
    examples=[
        {"input": "Revenue grew 23% YoY. Strong forward guidance.",      "output": "BULLISH"},
        {"input": "CEO resigned amid accounting irregularities.",          "output": "BEARISH"},
        {"input": "Q3 results in line with analyst consensus estimates.",    "output": "NEUTRAL"},
    ],
    user_input="The company beat earnings by 15% and raised its full-year dividend forecast.",
    output_fmt="Exactly one of: BULLISH, BEARISH, or NEUTRAL"
)

# ── Example 2: CoT Reasoning ────────────────────────────────
reasoning_config = PromptConfig(
    task_type=TaskType.REASONING,
    system_role="You are a careful logical reasoner.",
    user_input="If all Bloops are Razzles, and all Razzles are Lazzles, are all Bloops definitely Lazzles?",
    use_cot=True
)

print("=== Classification Result ===")
print(run_pipeline(classification_config))

print("\n=== Reasoning Result ===")
print(run_pipeline(reasoning_config))

Golden Rules of Prompt Engineering