M03: Prompts — Programming in Natural Language

Prompts are how you program Claude. This module teaches you the anatomy of effective prompts, battle-tested engineering patterns, and how to build a conversation manager that gives your agent a persistent memory.

Learning Objectives

• Explain the roles of system, user, and assistant messages in the Messages API
• Apply zero-shot, few-shot, and chain-of-thought prompting patterns and predict which works best for a given task
• Describe the stateless prompt-to-completion loop and why your code must manage context
• Build effective system prompts with structured sections for personaA role or identity assigned to Claude via the system prompt. For example, "You are a senior Python developer" makes Claude respond with that expertise and perspective., constraints, and output format
• Implement a ConversationManager class that maintains multi-turnA conversation with multiple back-and-forth exchanges between user and assistant. Since the API is stateless, your code must store and resend the full message history with each new turn. context

Anatomy of a Prompt: Message Roles

What this actually looks like in code: Here's the actual structure you send to the API. Notice how each piece has its own dedicated slot — system prompt separate, messages tagged with roles:

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system="You are a helpful coding assistant.",  # ← the "director"
    messages=[
        {"role": "user", "content": "How do I reverse a string?"},     # ← actor 1
        {"role": "assistant", "content": "Use slicing: s[::-1]"},       # ← actor 2
        {"role": "user", "content": "What about in JavaScript?"},       # ← actor 1 again
    ]  # Roles MUST alternate: user, assistant, user, assistant...
)

Prompt Engineering Patterns

What these patterns actually look like: Here's the same question sent three ways. Notice how the prompt structure changes — not the question itself:

# ZERO-SHOT — just the question, no help
"Classify this email as spam or not-spam: 'You won $1M! Click here!'"

# FEW-SHOT — show examples first, then ask
"""Classify these emails:
Email: 'Meeting tomorrow at 3pm' → not-spam
Email: 'Your invoice is attached' → not-spam
Email: 'FREE VIAGRA!!!' → spam

Now classify: 'You won $1M! Click here!' →"""

# CHAIN-OF-THOUGHT — ask for step-by-step reasoning
"""Classify this email as spam or not-spam: 'You won $1M! Click here!'

Think step by step:
1. What signals suggest spam?
2. What signals suggest legitimate?
3. Weigh the evidence
4. Final classification:"""

The zero-shot version uses the fewest tokens but gives Claude no guidance on format. Few-shot "teaches by example" — Claude mirrors the → spam/not-spam format from your examples. Chain-of-thought forces Claude to show its reasoning, making errors visible and easy to debug.

Zero-Shot vs. Few-Shot vs. Chain-of-Thought

The Prompt-to-Completion Loop

What the "envelope" actually looks like: Here's the literal data your code sends on Turn 3 of a conversation. Notice how the entire history from Turns 1 and 2 is included — you're photocopying every previous letter:

# Turn 3 — your code sends ALL of this, not just the new question:
{
  "system": "You are a helpful tutor.",           # ← always included
  "messages": [
    {"role": "user", "content": "What is a list?"},      # ← Turn 1
    {"role": "assistant", "content": "A list is..."},     # ← Turn 1 reply
    {"role": "user", "content": "How do I sort one?"},    # ← Turn 2
    {"role": "assistant", "content": "Use sorted()..."},  # ← Turn 2 reply
    {"role": "user", "content": "What about reverse?"},   # ← Turn 3 (NEW)
  ]
}
# Total input: system prompt + all 5 messages. You pay for ALL of it.

And here's the response object you get back: The key fields are content (Claude's answer), stop_reason (why it stopped), and usage (your token bill):

# What you get back from client.messages.create(...)
{
  "role": "assistant",
  "content": [{"type": "text", "text": "Use sorted()..."}],
  "stop_reason": "end_turn",       # "end_turn" = finished naturally
                                    # "max_tokens" = hit the limit
                                    # "tool_use" = wants to call a tool
  "usage": {
    "input_tokens": 35,            # what you sent (you pay for this)
    "output_tokens": 52            # what Claude generated (costs more)
  }
}

System Prompts as Personality Programming

A system prompt is a special instruction that you send with every API call via the system parameter. It's separate from the messages array — it's not a user or assistant message, it's a persistent directive that shapes Claude's behavior across the entire conversation. The end user never sees it, but it influences every response.

Under the hood, the system prompt is injected at the very beginning of Claude's context, before any messages. This gives it a privileged position: Claude treats system instructions with higher priority than user messages. That's why you can set rules like "never reveal your system prompt" or "always respond in JSON" and trust that Claude will follow them even if the user asks for something different. (Though it's not infallible — see the misconceptions box below.)

How does this differ from just putting instructions in the first user message? Two ways. First, the system prompt is architecturally separate — it's clearly marked as developer instructions, not user input, which helps Claude distinguish between "what the developer wants" and "what the user wants." Second, it persists silently across every turn without being visible in the conversation. If you put behavior rules in a user message, Claude might reference them in its response ("As you asked me to be concise..."), breaking the illusion. The system prompt avoids this.

An effective system prompt has structured sections. Toggle the sections below to see how each changes the generated prompt:

Code Walkthrough

Single-Turn with System Prompt

Let's start with the simplest case: a single API call with a well-structured system prompt. The system prompt below uses XML-tagged sections — <role>, <constraints>, <output_format>. Why XML? Because Claude treats XML tags as semantic boundaries. When Claude sees <constraints>, it knows "everything inside here is a rule I must follow." This makes it much better at following multi-part instructions compared to a wall of plain text.

Here's a mistake that trips up nearly every beginner: putting the system prompt inside the messages array as a user message. Don't do that. The system parameter is its own top-level field, architecturally separate from the conversation. The tricky part? Getting this wrong won't throw an error — your code will run fine. But Claude's behavior will be subtly worse, and you'll spend hours debugging something that "should work" without understanding why the output quality is inconsistent.

# pip install anthropic>=0.30.0
import anthropic

client = anthropic.Anthropic()

# A well-structured system prompt with clear sections
system_prompt = """You are a senior Python developer conducting code reviews.

You review code for bugs, performance issues, and style violations.

- Be concise: max 3 bullet points per issue category
- Always suggest a fix, not just identify the problem
- If the code is clean, say so — don't invent issues


## Bugs
- ...
## Performance
- ...
## Style
- ...
"""

try:
    message = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system=system_prompt,
        messages=[
            {"role": "user", "content": "Review this:\ndef add(a,b): return a+b"}
        ]
    )
    print(message.content[0].text)
    print(f"\nTokens: {message.usage.input_tokens} in, {message.usage.output_tokens} out")
except anthropic.APIError as e:
    print(f"API error: {e.status_code} - {e.message}")

// npm install @anthropic-ai/sdk@^0.30.0
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

const systemPrompt = `You are a senior Python developer conducting code reviews.

<role>You review code for bugs, performance issues, and style violations.</role>
<constraints>
- Be concise: max 3 bullet points per issue category
- Always suggest a fix, not just identify the problem
- If the code is clean, say so — don't invent issues
</constraints>
<output_format>
## Bugs
- ...
## Performance
- ...
## Style
- ...
</output_format>`;

try {
  const message = await client.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 1024,
    system: systemPrompt,
    messages: [
      { role: 'user', content: 'Review this:\ndef add(a,b): return a+b' }
    ]
  });
  console.log(message.content[0].text);
  console.log(`\nTokens: ${message.usage.input_tokens} in, ${message.usage.output_tokens} out`);
} catch (error) {
  if (error instanceof Anthropic.APIError) {
    console.error(`API error: ${error.status} - ${error.message}`);
  } else { throw error; }
}

Comparing Prompt Patterns

Now let's see the three patterns compete head-to-head. The code below sends the exact same math word problem three different ways — zero-shot, few-shot, and chain-of-thought — and prints the results side by side. This is the fastest way to build intuition for which pattern to reach for in your own projects.

One thing to watch in the output: notice how the input_tokens count differs between patterns. Few-shot examples are "free" in terms of accuracy, but they're not free in tokens — each example adds to your input cost. Chain-of-thought also produces longer outputs (Claude "thinks out loud"), so budget accordingly on both sides.

import anthropic

client = anthropic.Anthropic()

question = "A store sells apples for $1.50 each. If you buy 5 or more, you get a 20% discount. How much do 7 apples cost?"

prompts = {
    "zero-shot": question,
    "few-shot": f"""Example: A shirt costs $25. With a 10% discount, it costs $25 * 0.90 = $22.50.
Example: A book costs $15. Buy 3+ and get 15% off. 4 books = $15 * 4 * 0.85 = $51.00.

Now solve: {question}""",
    "chain-of-thought": f"""{question}

Let's solve this step by step:
1. First, determine the base price
2. Check if the discount applies
3. Calculate the discount amount
4. Compute the final price"""
}

for name, prompt in prompts.items():
    try:
        msg = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=300,
            messages=[{"role": "user", "content": prompt}]
        )
        print(f"\n{'='*40}")
        print(f"Pattern: {name}")
        print(f"Response: {msg.content[0].text[:200]}")
        print(f"Tokens: {msg.usage.input_tokens} in, {msg.usage.output_tokens} out")
    except anthropic.APIError as e:
        print(f"Error ({name}): {e.message}")

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

const client = new Anthropic();

const question = 'A store sells apples for $1.50 each. If you buy 5 or more, you get a 20% discount. How much do 7 apples cost?';

const prompts = {
  'zero-shot': question,
  'few-shot': `Example: A shirt costs $25. With a 10% discount, it costs $25 * 0.90 = $22.50.
Example: A book costs $15. Buy 3+ and get 15% off. 4 books = $15 * 4 * 0.85 = $51.00.

Now solve: ${question}`,
  'chain-of-thought': `${question}

Let's solve this step by step:
1. First, determine the base price
2. Check if the discount applies
3. Calculate the discount amount
4. Compute the final price`
};

for (const [name, prompt] of Object.entries(prompts)) {
  try {
    const msg = await client.messages.create({
      model: 'claude-sonnet-4-6',
      max_tokens: 300,
      messages: [{ role: 'user', content: prompt }]
    });
    console.log(`\n${'='.repeat(40)}`);
    console.log(`Pattern: ${name}`);
    console.log(`Response: ${msg.content[0].text.slice(0, 200)}`);
    console.log(`Tokens: ${msg.usage.input_tokens} in, ${msg.usage.output_tokens} out`);
  } catch (error) {
    if (error instanceof Anthropic.APIError) {
      console.error(`Error (${name}): ${error.message}`);
    } else { throw error; }
  }
}

ConversationManager Class

This is the most important code in the module — you will extend this class throughout the course. Let me walk you through it the way you'd think about building it yourself.

The constructor stores three things: the system prompt, the model name, and an empty messages list. That messages list is the heart of the entire class. Since the API is stateless, this Python list is literally the only place the conversation exists. If your process crashes and you lose this list, the entire conversation history is gone — poof. (In M08, you'll learn how to persist this to a database so it survives restarts.)

Now let's look at the send() method, where the real magic happens. The flow is: append the user message to the list, call the API with the full history, then append Claude's response. By keeping both sides in the list, each subsequent call automatically includes the full conversation context. Here's the subtle but critical detail: if the API call fails, we pop() the user message back off the list. Why? Without this rollback, you'd have an orphaned user message sitting in the list with no assistant reply after it. The next call would send two consecutive user messages, violate the strict role alternation rule, and throw a confusing error that doesn't mention the real cause.

Finally, the demo at the bottom sends two turns and prints the token counts. Pay attention to the numbers: the second call uses noticeably more input tokens than the first, because it includes the entire first turn's content. This is the cost growth pattern you must plan for in any long-running agent — and it's exactly why M08 teaches conversation summarization techniques.

import anthropic

class ConversationManager:
    """Manages multi-turn conversations with Claude."""

    def __init__(self, system_prompt: str, model: str = "claude-sonnet-4-6"):
        self.client = anthropic.Anthropic()
        self.system = system_prompt
        self.model = model
        self.messages: list[dict] = []

    def send(self, user_message: str) -> tuple[str, dict]:
        """Send a message and get a response. Returns (text, usage)."""
        self.messages.append({"role": "user", "content": user_message})

        try:
            response = self.client.messages.create(
                model=self.model,
                max_tokens=1024,
                system=self.system,
                messages=self.messages,
            )
            assistant_text = response.content[0].text
            self.messages.append({"role": "assistant", "content": assistant_text})

            return assistant_text, {
                "input_tokens": response.usage.input_tokens,
                "output_tokens": response.usage.output_tokens,
            }
        except anthropic.APIError as e:
            self.messages.pop()  # Remove failed user message
            raise

    def get_history(self) -> list[dict]:
        """Return the full conversation history."""
        return self.messages.copy()

    def clear(self):
        """Clear conversation history (keeps system prompt)."""
        self.messages = []


# Usage
conv = ConversationManager(
    system_prompt="You are a helpful Python tutor. Be concise."
)

try:
    reply, usage = conv.send("What is a list comprehension?")
    print(f"Claude: {reply}")
    print(f"Tokens: {usage}")

    reply, usage = conv.send("Show me an example with filtering.")
    print(f"\nClaude: {reply}")
    print(f"Tokens: {usage}")
    print(f"History length: {len(conv.get_history())} messages")
except anthropic.APIError as e:
    print(f"Error: {e.message}")

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

class ConversationManager {
  constructor(systemPrompt, model = 'claude-sonnet-4-6') {
    this.client = new Anthropic();
    this.system = systemPrompt;
    this.model = model;
    this.messages = [];
  }

  async send(userMessage) {
    this.messages.push({ role: 'user', content: userMessage });

    try {
      const response = await this.client.messages.create({
        model: this.model,
        max_tokens: 1024,
        system: this.system,
        messages: this.messages,
      });
      const assistantText = response.content[0].text;
      this.messages.push({ role: 'assistant', content: assistantText });

      return {
        text: assistantText,
        usage: {
          inputTokens: response.usage.input_tokens,
          outputTokens: response.usage.output_tokens,
        },
      };
    } catch (error) {
      this.messages.pop(); // Remove failed user message
      throw error;
    }
  }

  getHistory() { return [...this.messages]; }
  clear() { this.messages = []; }
}

// Usage
const conv = new ConversationManager(
  'You are a helpful Python tutor. Be concise.'
);

try {
  let result = await conv.send('What is a list comprehension?');
  console.log(`Claude: ${result.text}`);
  console.log(`Tokens:`, result.usage);

  result = await conv.send('Show me an example with filtering.');
  console.log(`\nClaude: ${result.text}`);
  console.log(`Tokens:`, result.usage);
  console.log(`History length: ${conv.getHistory().length} messages`);
} catch (error) {
  if (error instanceof Anthropic.APIError) {
    console.error(`Error: ${error.message}`);
  } else { throw error; }
}

Hands-On Exercise

Environment Setup

If you completed the M01 lab, you're already set up. Otherwise:

pip install "anthropic>=0.30.0"           # or: npm install "@anthropic-ai/sdk@^0.30.0"
export ANTHROPIC_API_KEY="your-key-here"  # or (Windows): set ANTHROPIC_API_KEY=your-key-here

Step 1: Build a Code Review System Prompt

A great system prompt is the highest-leverage thing you can write for an agent. This step builds one with 5 XML-tagged sections — the same structure production teams use. XML tags help Claude parse multi-part instructions cleanly.

Create a new file called review_agent.py (or review_agent.mjs):

import anthropic

client = anthropic.Anthropic()

REVIEW_SYSTEM_PROMPT = """You are a senior software engineer conducting code reviews.

<role>You review code for correctness, performance, security, and style.</role>
<expertise>Python, JavaScript, SQL. You know OWASP top 10 and PEP 8.</expertise>
<review_criteria>
- Bugs: logic errors, off-by-one, null handling
- Performance: unnecessary loops, missing caching opportunities
- Security: injection risks, hardcoded secrets, unsafe deserialization
- Style: naming conventions, function length, missing docstrings
</review_criteria>
<output_format>
For each category with findings, use this format:
## [Category]
- **Issue**: description
- **Fix**: suggested code change
If a category has no issues, omit it entirely.
</output_format>
<tone>Be constructive and specific. Praise good patterns. Never be dismissive.</tone>"""

# Test the system prompt with a simple review
test_code = '''def get_user(id):
    query = f"SELECT * FROM users WHERE id = {id}"
    return db.execute(query)'''

try:
    msg = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system=REVIEW_SYSTEM_PROMPT,
        messages=[{"role": "user", "content": f"Review this code:\n```python\n{test_code}\n```"}]
    )
    print(msg.content[0].text)
    print(f"\nTokens: {msg.usage.input_tokens} in, {msg.usage.output_tokens} out")
except anthropic.APIError as e:
    print(f"Error: {e.message}")

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

const client = new Anthropic();

const REVIEW_SYSTEM_PROMPT = `You are a senior software engineer conducting code reviews.

<role>You review code for correctness, performance, security, and style.</role>
<expertise>Python, JavaScript, SQL. You know OWASP top 10 and PEP 8.</expertise>
<review_criteria>
- Bugs: logic errors, off-by-one, null handling
- Performance: unnecessary loops, missing caching opportunities
- Security: injection risks, hardcoded secrets, unsafe deserialization
- Style: naming conventions, function length, missing docstrings
</review_criteria>
<output_format>
For each category with findings, use this format:
## [Category]
- **Issue**: description
- **Fix**: suggested code change
If a category has no issues, omit it entirely.
</output_format>
<tone>Be constructive and specific. Praise good patterns. Never be dismissive.</tone>`;

const testCode = `def get_user(id):
    query = f"SELECT * FROM users WHERE id = {id}"
    return db.execute(query)`;

try {
  const msg = await client.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 1024,
    system: REVIEW_SYSTEM_PROMPT,
    messages: [{ role: 'user', content: `Review this code:\n\`\`\`python\n${testCode}\n\`\`\`` }]
  });
  console.log(msg.content[0].text);
  console.log(`\nTokens: ${msg.usage.input_tokens} in, ${msg.usage.output_tokens} out`);
} catch (error) {
  console.error(`Error: ${error.message}`);
}

Run it: python review_agent.py (or node review_agent.mjs)

Step 2: Compare Prompt Patterns

Now let's see how zero-shot, few-shot, and chain-of-thought affect the same review task. This step sends the same buggy code three ways and prints the results so you can compare quality and token cost side by side.

Create a new file called pattern_compare.py (or pattern_compare.mjs):

import anthropic

client = anthropic.Anthropic()

code = '''def process_items(items):
    result = []
    for i in range(len(items)):
        if items[i] != None:
            result.append(items[i].upper())
    return result'''

patterns = {
    "zero-shot": f"Review this Python code for issues:\n```python\n{code}\n```",
    "few-shot": f"""Here are example code reviews:

Code: `x = x + 1` → Style: Use `x += 1` for augmented assignment.
Code: `if x == None` → Bug: Use `is None` instead of `== None` for identity checks.

Now review this code:
```python
{code}
```""",
    "chain-of-thought": f"""Review this Python code step by step:
```python
{code}
```

Think through it methodically:
1. Read each line and check for bugs
2. Look for performance issues
3. Check for style violations
4. Summarize your findings""",
}

for name, prompt in patterns.items():
    try:
        msg = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=500,
            messages=[{"role": "user", "content": prompt}]
        )
        print(f"\n{'='*50}")
        print(f"Pattern: {name}")
        print(f"Tokens: {msg.usage.input_tokens} in, {msg.usage.output_tokens} out")
        print(f"Response:\n{msg.content[0].text[:300]}")
    except anthropic.APIError as e:
        print(f"Error ({name}): {e.message}")

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

const client = new Anthropic();

const code = `def process_items(items):
    result = []
    for i in range(len(items)):
        if items[i] != None:
            result.append(items[i].upper())
    return result`;

const patterns = {
  'zero-shot': `Review this Python code for issues:\n\`\`\`python\n${code}\n\`\`\``,
  'few-shot': `Here are example code reviews:\n\nCode: \`x = x + 1\` → Style: Use \`x += 1\`.\nCode: \`if x == None\` → Bug: Use \`is None\`.\n\nNow review:\n\`\`\`python\n${code}\n\`\`\``,
  'chain-of-thought': `Review this step by step:\n\`\`\`python\n${code}\n\`\`\`\n\n1. Check for bugs\n2. Performance issues\n3. Style violations\n4. Summarize`,
};

for (const [name, prompt] of Object.entries(patterns)) {
  try {
    const msg = await client.messages.create({
      model: 'claude-sonnet-4-6',
      max_tokens: 500,
      messages: [{ role: 'user', content: prompt }]
    });
    console.log(`\n${'='.repeat(50)}`);
    console.log(`Pattern: ${name}`);
    console.log(`Tokens: ${msg.usage.input_tokens} in, ${msg.usage.output_tokens} out`);
    console.log(`Response:\n${msg.content[0].text.slice(0, 300)}`);
  } catch (error) {
    console.error(`Error (${name}): ${error.message}`);
  }
}

Run it: python pattern_compare.py (or node pattern_compare.mjs)

Step 3: Multi-Turn Review Conversation

Now combine the system prompt from Step 1 with the ConversationManager from the code walkthrough to have a multi-turn review conversation. This demonstrates how context builds across turns — and how token costs grow. This step uses the ConversationManager class from the Code Walkthrough section above.

Create a new file called review_conversation.py (or review_conversation.mjs). Copy the ConversationManager class from the Code Walkthrough above, then add:

# After the ConversationManager class definition...

REVIEW_SYSTEM_PROMPT = """You are a senior software engineer conducting code reviews.
<role>Review code for correctness, performance, security, and style.</role>
<output_format>Use ## Category headers with bullet points. Be concise.</output_format>
<tone>Be constructive. Praise good patterns.</tone>"""

conv = ConversationManager(system_prompt=REVIEW_SYSTEM_PROMPT)
total_in = 0
total_out = 0

turns = [
    "Review this:\n```python\ndef get_user(id):\n    query = f'SELECT * FROM users WHERE id = {id}'\n    return db.execute(query)\n```",
    "Can you show me the fixed version with parameterized queries?",
    "Now add error handling for the case where the user is not found.",
    "What about connection pooling — is that important here?",
    "Summarize all the improvements we discussed in a checklist.",
]

for i, turn in enumerate(turns, 1):
    try:
        reply, usage = conv.send(turn)
        total_in += usage["input_tokens"]
        total_out += usage["output_tokens"]
        print(f"\n--- Turn {i} ---")
        print(f"You: {turn[:60]}...")
        print(f"Claude: {reply[:150]}...")
        print(f"This turn: {usage['input_tokens']} in, {usage['output_tokens']} out")
        print(f"Cumulative: {total_in} in, {total_out} out")
    except Exception as e:
        print(f"Error on turn {i}: {e}")
        break

print(f"\n{'='*50}")
print(f"Total: {len(conv.get_history())} messages, {total_in} input + {total_out} output tokens")

// After the ConversationManager class definition...

const conv = new ConversationManager(
  `You are a senior software engineer conducting code reviews.
<role>Review code for correctness, performance, security, and style.</role>
<output_format>Use ## Category headers with bullet points. Be concise.</output_format>
<tone>Be constructive. Praise good patterns.</tone>`
);

let totalIn = 0, totalOut = 0;
const turns = [
  "Review this:\n```python\ndef get_user(id):\n    query = f'SELECT * FROM users WHERE id = {id}'\n    return db.execute(query)\n```",
  'Can you show me the fixed version with parameterized queries?',
  'Now add error handling for the case where the user is not found.',
  'What about connection pooling — is that important here?',
  'Summarize all the improvements we discussed in a checklist.',
];

for (let i = 0; i < turns.length; i++) {
  try {
    const { text, usage } = await conv.send(turns[i]);
    totalIn += usage.inputTokens;
    totalOut += usage.outputTokens;
    console.log(`\n--- Turn ${i + 1} ---`);
    console.log(`You: ${turns[i].slice(0, 60)}...`);
    console.log(`Claude: ${text.slice(0, 150)}...`);
    console.log(`This turn: ${usage.inputTokens} in, ${usage.outputTokens} out`);
    console.log(`Cumulative: ${totalIn} in, ${totalOut} out`);
  } catch (error) {
    console.error(`Error on turn ${i + 1}: ${error.message}`);
    break;
  }
}
console.log(`\n${'='.repeat(50)}`);
console.log(`Total: ${conv.getHistory().length} messages, ${totalIn} input + ${totalOut} output tokens`);

Run it: python review_conversation.py (or node review_conversation.mjs)

Verify Everything Works

Run both scripts to confirm your setup:

python review_agent.py && python pattern_compare.py && python review_conversation.py

Stretch Goals (Optional)

• Auto-summarization: When token count exceeds 80% of the context window, automatically summarize older turns
• Prompt template library: Build a function that switches between zero-shot, few-shot, and CoT patterns with a single parameter

Knowledge Check

Test your understanding of prompts, patterns, and conversation management.

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    ______="You are a helpful assistant.",
    messages=[{"role": "user", "content": "Hello!"}]
)

Module Summary