Course Wrap Up

Thirteen modules ago you opened a terminal and installed the Anthropic SDK. Since then you've built a small pile of working programs, each one teaching a specific slice of the production Claude API surface. This is the last lesson. Not because there's nothing more to learn — there's always more — but because you now have enough of the foundation to go build anything you want.

What you built

Run back through the arc:

• A multi-turn chat function with system prompts, temperature control, streaming, and structured output extraction. The building block every Claude application sits on top of.
• A prompt evaluation pipeline with generated datasets, model-based grading, and code-based syntax validation — the thing that turns "I think this prompt is better" into "the score went up 2.1 points."
• An iteratively-engineered meal plan prompt that climbed from 2.3 to 8+ on the eval score by applying clarity, specificity, XML structure, and examples one at a time.
• A reminder-setting tool assistant with three chained tools (get_current_datetime, add_duration_to_datetime, set_reminder) and a conversation loop that handles multi-turn tool use, error recovery, and first-party tools like text editor and web search.
• A hybrid RAG retriever combining VoyageAI embeddings with BM25 lexical search, merged through reciprocal rank fusion — production-shaped retrieval, not a toy.
• A prompt-cached document assistant using extended thinking, image and PDF support, citations, and the Files API with code execution. Most of the advanced feature surface in one codebase.
• A full MCP server-and-client pair written with FastMCP — tools, resources, and prompts — plus a CLI chatbot that consumes them via a custom MCP client wrapper.
• Working familiarity with Claude Code as an agent reference implementation and a concrete understanding of how to extend it with your own MCP servers.
• A mental library of four workflow patterns (evaluator-optimizer, parallelisation, chaining, routing) and two agent design principles (abstract combinable tools, environment inspection) — the vocabulary you'll use to describe and build everything that comes next.

That's a lot of code. More importantly, it's a lot of engineering judgment about when and why to reach for each tool.

The skills you actually earned

The code is the scaffolding. The skills are the durable outcome:

• Make authenticated Claude API requests with proper error handling, streaming, and structured output.
• Design prompts systematically using clarity, specificity, XML structure, and examples — and measure their quality with real evals.
• Build prompt evaluation pipelines with mixed model and code graders that give you objective metrics to iterate against.
• Design and implement tool use from schemas through conversation loops, including first-party and built-in tools.
• Build RAG pipelines with chunking, embeddings, vector search, lexical search, and hybrid retrieval.
• Use advanced features — extended thinking, vision, PDFs, citations, prompt caching, code execution — in production-shaped ways.
• Build MCP servers and clients using FastMCP and the official SDK, with tools, resources, and prompts.
• Work effectively with Claude Code using context-plan-implement workflows and MCP extensions.
• Choose between workflow patterns and agents based on task definition and reliability requirements, then design and test whichever you picked.

None of these skills are theoretical. Every one of them came from writing code that ran against the real API. That's the difference between knowing about the Claude API and being able to build on it.

Three next-step projects

If you're looking for what to build next, three projects that each stretch you into new territory while building directly on what you already have:

1. Add web search to your RAG pipeline. Take the hybrid retriever from Module 7 and add Claude's built-in web search tool as a third source, fused into the same Retriever class via reciprocal rank fusion. Now your RAG layer can answer questions about both your private documents and the live internet from the same entry point. It's a small code change and a big capability jump.

2. Build a Sentry-integrated Claude Code workflow. Register the sentry-mcp server with Claude Code, then build a second internal MCP server that knows about your codebase conventions and can propose fixes. Combine the two: ask Claude Code to fetch the top three Sentry errors, plan fixes, and produce pull requests. You'll exercise Module 9's MCP server building, Module 10's Claude Code workflows, and Module 11's agent design all in one project.

3. Deploy an agent to a production endpoint. Pick a single, well-defined task from your actual work — document processing, classification, a customer-facing Q&A — and turn it into an HTTP endpoint backed by a Claude agent. Do the boring production work: prompt caching for the stable parts, an eval against real inputs, observability on tool calls, error handling for failures, rate limits. This is the project that exercises every module in the course and teaches you what production actually feels like.

Any one of these is more than enough to keep you busy for a couple of weekends, and all three would meaningfully level you up as a Claude engineer.

The honest closing

Everything in this course was chosen because it's part of the real working surface for building on Claude. Every primitive — the API, the schemas, the tools, the MCP protocol, the agent patterns — is a building block for something you're going to ship. Not every block is equally important on every project, but all of them together are the vocabulary for designing Claude-native software.

Go build something. Start with the simplest version of a feature you actually care about. Use an eval to measure it. Iterate against the eval. Reach for more advanced features only when the simpler ones stop working. Resist the pull to use every feature in the course at once — the most effective production systems you'll build are the ones that pick the right two or three and use them well.

The course is done. The real work starts at the next client.messages.create() call you write.