Claude Platform 101

Overview

There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there.

An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting.

Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live. This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.

We start from first principles:

what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.

You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you.

You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench. The middle of the course extends an agent beyond your own code:

Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.

The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back.

A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters:

you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.

Recommended prerequisites Comfort reading and writing code in at least one language, plus basic command-line familiarity. The demos use the TypeScript SDK (@anthropic-ai/sdk) with Node and npm.

You don't need to be a TypeScript expert, but you should be able to follow along and run a script. (The platform also offers a Python SDK; the course examples are in TypeScript.) You'll need an Anthropic Console account and an API key from platform.claude.com, plus a small amount of prepaid credit to run the examples. You don't need prior experience building with LLMs.

Who this is for Developers who've used Claude in a chat window and want to build it into their own applications, whether you're adding AI features to an existing product or prototyping an agent from scratch. If you've sent a handful of API calls but stalled at "how do I make this act on its own" or "how do I connect it to my real systems," this course is the bridge from a single request to a production agent.

You don't need prior agent experience; each lesson builds on the one before it.

Syllabus

• What is the Claude Developer Platform?
Get clear on what the platform is and how it differs from the chat app you've already used. Send your first messages.create call, then pick the right model — Opus, Sonnet, or Haiku — by running a quick eval instead of guessing.
• Teaching your Agent
This is where a single request becomes an agent. Build the agent loop by hand, define your own tools, collapse the scaffolding with the SDK's Tool Runner, and turn on extended thinking for the problems that need it.
• Extending your Agent
Reach past your own code with Anthropic's built-in tools, Skills that package a procedure once, and MCP servers that connect Claude to third-party services. Finish with the context-management patterns that keep a long-running agent inside the window and affordable.
• Managed Agents
Up to now you've run the loop yourself — managed agents hand it to Anthropic. Learn when that trade is worth it, then build one end to end and consume the event stream as it runs in a sandbox.
• Building with Claude Code
A short capstone that ties the course together: stub a file, hand it to Claude Code with one well-formed prompt, and review the diff. It calls the same primitives you built by hand — Claude Code skips the keystrokes, not the understanding.

---

Subjects

Artificial Intelligence