Free Resources and Where to Go Next
Everything in this closing module is free, official, and maintained by Anthropic — bookmark it as your reference map, then go build something with your own data.
Imagine you just finished a big Lego set using an instruction booklet somebody handed you. This page is the back cover of that booklet — it points you to where the Lego company keeps every other booklet, its website, and its idea videos, so you can keep building without waiting for someone to hand you the next set of instructions. One catch: Lego keeps reprinting its catalog, so always check the newest copy instead of trusting the picture you remember from a few months ago.
You've covered the whole arc
☺ Like you're 10: You've basically finished a whole obstacle course — getting your key, sending messages, giving Claude tools, teaching it to search your own documents, and keeping it safe. This page is the map of where the obstacle course keeps adding new sections.
Across this course you've covered getting API access, the Messages API shape, prompting techniques, tool use and structured outputs, RAG, agentic patterns, MCP, Claude Code, evaluation, and safety. None of that knowledge is static — Anthropic ships new models, new API features, and new docs structure on an ongoing basis. This module is your jumping-off point: a categorized list of the official places to keep learning, plus a suggestion for what to do with the next few hours.
Model names, prices, and context windows change between cohorts of this course. Before you hard-code a model ID into a real project, re-check it against the live Models Overview page rather than trusting a screenshot or an old tutorial — including this one.
Official docs & reference
☺ Like you're 10: Think of this as the school's official noticeboard, not a friend's notes — the docs site is the one place that's always kept current.
The docs site (platform.claude.com — both docs.claude.com and console.anthropic.com now redirect here) is the single source of truth for anything code-facing: exact parameter names, response shapes, and current limits. Here's the subset worth bookmarking, grouped by when you'll reach for it.
Start here
| Resource | What it covers |
|---|---|
| Get started | The official onboarding walkthrough for a first API call. |
| Get an API key | Console → Settings → API keys → Create key; the key (prefix sk-ant-) is shown in full only once. |
| Authentication | Storing keys safely, the ANTHROPIC_API_KEY env var, and Workload Identity Federation for production. |
| Models overview | The current model lineup, context windows, pricing, and thinking support — always check this live. |
| API overview | The Messages, Batches, Token Counting, and Models APIs, plus the beta Files/Skills/Agents APIs. |
Building features
| Resource | What it covers |
|---|---|
| Prompting best practices | The consolidated reference for clarity, examples, XML tags, roles, long context, and migration notes. |
| Tool use overview | Tool definitions, the tool_use/tool_result loop, parallel calls, and error handling. |
| Structured outputs | Guaranteed JSON via output_config.format and strict tool schemas. |
| Handling stop reasons | The full stop_reason table — end_turn, tool_use, pause_turn, refusal, and more. |
| Embeddings (RAG) | Why Anthropic doesn't ship its own embedding model, and how Voyage AI plugs into retrieval. |
| Reduce hallucinations | Quote-grounding, citation requirements, and verification techniques with full example prompts. |
| Mitigate jailbreaks | Direct vs. indirect prompt injection defenses for agents that read untrusted tool output. |
| Define success criteria & build evals | SMART criteria, grading approaches, and eval-set design. |
| Agent SDK overview | Embedding Claude Code's agent loop in your own application, outside the CLI. |
| Claude Code docs | CLAUDE.md, subagents, hooks, permission modes, and the VS Code extension. |
| Model Context Protocol | The open standard for connecting Claude to external tools, resources, and prompts. |
Scaling to production
| Resource | What it covers |
|---|---|
| Choosing a model | Trading capability against speed and cost across the model tiers. |
| Prompt caching | Up to 90% cheaper repeated input via cache reads, with 5-minute or 1-hour TTLs. |
| Batch processing | A flat 50% discount on async workloads via the Message Batches API. |
| Rate limits | Token-bucket limits by usage tier, 429 handling, and exponential backoff. |
| Claude on Amazon Bedrock | Running Claude through AWS instead of the direct API. |
| Claude on Vertex AI | The Google Cloud equivalent, including request-shape differences from the direct API. |
| Usage and Cost Admin API | Programmatic token/cost tracking by model, workspace, and API key. |
Hands-on repos
Docs tell you the shape of the API; these repos let you run real, working code against it. All three are maintained directly under the anthropics GitHub organization.
git clone https://github.com/anthropics/claude-cookbooks.git
git clone https://github.com/anthropics/courses.git
git clone https://github.com/anthropics/prompt-eng-interactive-tutorial.gitOpen any of them in VS Code, set ANTHROPIC_API_KEY in a .env file or your integrated terminal's environment, and run the notebooks with the Jupyter extension — the same setup you've been using throughout this course.
- anthropics/claude-cookbooks — Jupyter notebooks covering classification, RAG, summarization, tool-use agents (customer service, calculators, SQL), third-party integrations (Pinecone, Voyage AI), multimodal work (vision, charts, PDFs), and advanced patterns like Haiku+Opus sub-agent pipelines and prompt caching. (Renamed from the older
anthropic-cookbook— this is the current canonical repo.) - anthropics/courses — five self-paced, notebook-based courses in recommended order: API Fundamentals, Prompt Engineering Interactive Tutorial, Real World Prompting, Prompt Evaluations, and Tool Use. Requires an API key.
- anthropics/prompt-eng-interactive-tutorial — the same prompt-engineering tutorial as a standalone, 9-chapter, exercise-driven repo if you want to jump straight to prompting drills.
For a browser-based, no-clone option, Anthropic Academy (anthropic.com/learn) is the landing page for Anthropic's structured course catalog, hosted on the interactive platform at anthropic.skilljar.com — 20+ free courses spanning both developer topics (Claude Platform 101, Building with the Claude API, MCP, Claude Code) and business/AI-fluency tracks, with registration but no Anthropic account required.
Engineering case studies & deeper reading
Once the mechanics feel familiar, the highest-value reading is Anthropic's own engineering blog at anthropic.com/engineering — real production write-ups, not marketing copy. A few worth prioritizing:
- Building effective agents (Dec 2024) — the workflows-vs-agents framework and the six patterns (prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer, autonomous agents) this course's agentic-systems modules were built on.
- How we built our multi-agent research system (Jun 2025) — orchestrator-worker patterns at production scale.
- Claude Code: Best practices for agentic coding (Apr 2025) — the thinking behind CLAUDE.md, subagents, and permission modes.
- Writing effective tools for agents — with agents (Sep 2025) and Effective context engineering for AI agents (Sep 2025) — practical tool-design and context-management guidance beyond what fits in the API reference.
For the research and policy side of Claude — useful once you're shipping something real rather than experimenting — see Constitutional AI: Harmlessness from AI Feedback, the Responsible Scaling Policy, and the Usage Policy (which spells out the human-in-the-loop and disclosure requirements for high-risk domains like healthcare, legal, and finance). And on the technique side, Introducing Contextual Retrieval and Introducing the Citations API go deeper into the RAG techniques this course covered.
Anthropic's official YouTube channel, youtube.com/@anthropic-ai, is worth subscribing to for launch walkthroughs and talks that complement the written docs.
Bookmark the live docs — Models Overview, Prompting Best Practices, the engineering blog — and re-check them before each new project. Anthropic updates these pages continuously.
Copying a model ID or a pricing table from an old tutorial (including this course, a few months from now) straight into production code without verifying it's still current.
Foxy: Wait — so everything I just memorized about model names and prices might already be out of date?
Professor Owl: Not wrong today, just perishable. Anthropic ships new models and docs updates on an ongoing basis, so a hard-coded model ID is a snapshot, not a promise.
Foxy: So do I have to relearn this whole course every few months?
Remy: Nope — you relearn nothing. You just build the habit of re-checking one page, the Models Overview, before you ship. That habit is worth more than memorizing today's model ID.
Keep going: your next project
☺ Like you're 10: Reading about riding a bike doesn't make you able to ride one — you have to get on, wobble, and fall over once where nobody wrote the instructions for exactly your fall.
The fastest way to lose everything you just learned is to stop the moment the course ends. The fastest way to keep it is to immediately point it at a real problem.
Look back at the capstone projects that followed these foundation modules and pick the one closest to a domain you actually work in — customer support, internal tooling, research, whatever it is. Don't just re-read it: fork it, swap in your own data, your own documents, your own users' questions, and rebuild it end to end. The gap between "I followed a tutorial" and "I can build this" closes the moment you hit a bug that isn't in anyone's docs and have to reason your way out using the mental models from this course — tool_use loops, context windows, evals, guardrails — rather than a code sample.
From there, staying current is mostly a matter of habit: check the Models Overview page before starting anything new, skim anthropic.com/engineering periodically for new patterns, and treat the claude-cookbooks repo as a living reference you return to, not something you finish once.
Pick one capstone from this course that's closest to your own work or interests. Clone its starting point (or rebuild its core loop from scratch using what you learned in this course), then replace every piece of sample data with your own — your own documents for RAG, your own support tickets for classification, your own codebase for an agent. Get it running end to end against the live Claude API with your own key, then write down the one thing that broke that no tutorial warned you about.
You should now be able to name the single source of truth for Claude's docs (platform.claude.com), list the three official free repos to keep practicing with, and explain why you should never hard-code a model ID without rechecking the live Models Overview page first. When you're ready to test what stuck, head back to Capstone Support and rebuild one of the projects against your own real data.
Check your answers
- Where should you always double-check model names, prices, and context windows before shipping? The live Models Overview page at platform.claude.com — not a cached tutorial, screenshot, or old blog post, since Anthropic updates the model lineup on an ongoing basis.
- What are the three official, free repos maintained by Anthropic for hands-on practice? anthropics/claude-cookbooks (real-world notebooks across classification, RAG, tool-use agents, and multimodal work), anthropics/courses (five self-paced notebook courses), and anthropics/prompt-eng-interactive-tutorial (a standalone 9-chapter prompting drill set).
- What's the fastest way to actually retain everything covered in this course? Stop reading and start building — pick one capstone close to your own work, swap in your own real data, and rebuild it end to end against the live API with your own key until you hit a bug nobody's docs cover.