Learning Objectives

• Send well-formed requests to the Claude Messages API and interpret the response structure
• Apply prompt engineering techniques—including system prompts, few-shot examples, and chain-of-thought—to improve output quality and consistency
• Extract structured data from Claude responses using JSON mode and schema validation
• Implement tool use and function calling to connect Claude to external APIs and data sources
• Stream responses token-by-token for low-latency user interfaces
• Send image and document inputs using the vision API and handle multimodal responses
• Build and manage multi-turn conversation state correctly across API calls
• Measure and optimize token usage to control cost and reduce latency
• Apply content filtering, input validation, and output guardrails appropriate for production deployments
• Design a complete application architecture that integrates Claude reliably within a larger system

Course Outline

Module 1: Claude API Foundations

Students get oriented with the Anthropic ecosystem: account setup, API key management, and SDK installation. The module walks through the anatomy of a Messages API request and response—model selection, the messages array, role conventions, stop sequences, and token limits. Students make their first API calls via the SDK and via raw HTTP to build a clear mental model of what the library abstracts.

Module 2: System Prompts and Conversation Design

This module covers how to use the system prompt to set persona, scope, and behavioral constraints. Students learn how Claude processes the conversation turn structure, how context window size affects behavior, and how to manage multi-turn state by maintaining and trimming the messages array. Labs include building a simple stateful chat loop and testing the effect of different system prompt formulations on response consistency.

Module 3: Prompt Engineering Techniques

Students work through practical prompt engineering patterns: zero-shot vs. few-shot prompting, explicit output formatting instructions, chain-of-thought and step-back prompting, and techniques for reducing hallucination. The module also covers how to write prompts that are robust to variation in user input, and how to evaluate prompt quality systematically rather than by intuition. Students build a small prompt evaluation harness during the lab.

Module 4: Structured Output and Schema Enforcement

Reliably extracting machine-readable data from Claude responses is the focus of this module. Students learn how to prompt for JSON output, validate responses against a Pydantic schema, and handle cases where the model returns malformed or partial output. The module introduces retry logic and output repair patterns. Lab work involves building a document parsing pipeline that extracts structured fields from unstructured text.

Module 5: Tool Use and Function Calling

This module covers the Claude tool use protocol end to end: defining tools with JSON schemas, sending tool definitions in the API request, parsing tool_use content blocks from the response, executing the corresponding function locally, and returning tool results in the next turn. Students learn how to handle multi-step agentic loops where Claude calls tools in sequence. The lab connects Claude to a live weather API and a local SQLite database query function.

Module 6: Streaming Responses

Students learn to use the streaming API to receive and render tokens incrementally, which is essential for responsive chat interfaces and long-generation tasks. The module covers server-sent events, the stream event types Claude emits (content_block_delta, message_delta, etc.), and how to handle stream interruption and error recovery. A lab integrates streaming output into a simple terminal UI and then into a FastAPI endpoint that proxies the stream to a browser client.

Module 7: Vision and Multimodal Inputs

This module introduces the vision API: encoding images as base64 or referencing URLs, understanding supported formats and size limits, and writing prompts that work well with visual context. Students also learn to send PDF and text file content as document blocks. Labs cover practical use cases including image captioning, extracting data from screenshots, and combining image and text context in a single prompt.

Module 8: Token Management and Cost Control

Students learn to read and interpret usage fields in API responses, estimate token counts before making requests, and make deliberate tradeoffs between context length, output length, and cost. The module covers prompt caching—how it works and when it provides savings—along with strategies for summarizing long conversation histories to stay within context limits without losing relevant information. Students profile the token usage of an existing application and identify optimization opportunities.

Module 9: Latency Optimization and Reliability Patterns

This module addresses the engineering concerns that arise when Claude is on the critical path of a user-facing request. Topics include choosing the right model tier for a given task, batching requests where appropriate, setting timeouts and implementing exponential backoff for rate limit errors, and caching deterministic responses. Students also learn how to degrade gracefully when the API is unavailable and how to design workflows that tolerate partial failures.

Module 10: Safety, Content Filtering, and Guardrails

Students learn how to implement layered safety controls in Claude-powered applications. The module covers input validation to prevent prompt injection, using system prompts to constrain Claude’s scope, detecting and handling refusals and off-topic responses, and adding output classifiers for high-risk domains. Students also review Anthropic’s usage policies and learn how to document their application’s safety posture for internal review or compliance purposes.

Module 11: Application Architecture and Integration Patterns

This module takes a step back to look at how Claude fits into larger systems. Topics include synchronous vs. asynchronous integration patterns, using Claude in background job queues, orchestrating multiple model calls in a pipeline, and deciding when to use Claude vs. a simpler rule-based approach. Students review reference architectures for common application types: customer-facing chat, document processing, and internal tooling.

Module 12: Capstone Project and Code Review

Students spend the final module building a complete small application that integrates at least three of the course’s technical areas—for example, a document Q&A tool using vision inputs, structured output, and tool use with a retrieval backend. Instructors conduct a structured code review with each student or team, covering correctness, prompt robustness, error handling, and cost efficiency. The session closes with a discussion of next steps, additional Anthropic documentation, and community resources.