Claude Platform 101

What the course is

Anthropic Academy's introduction to the Claude Developer Platform — the on-ramp from "I use Claude" to "I build on Claude." It walks from your first API call through the agent loop, tools, thinking, MCP, and the build-vs-host decision, ending with Claude Code and cost management. It's the natural prerequisite for the CCDV-F exam (ccdv-f-exam).

First API call and model choice

Messages API — the core request/response surface: send a list of messages plus parameters, get back content blocks (see messages-api for the full shape).
Model selection — pick the cheapest model that meets the quality bar: Haiku (fast/cheap, high-volume and routing tasks), Sonnet (balanced default for most production work), Opus (hardest reasoning, agentic depth). Details in model-family.
Rule of thumb from the course: prototype on a strong model to prove the task is possible, then downshift and measure, rather than starting cheap and wondering why quality is poor.

The agent loop

Agent loop — the fundamental pattern behind everything agentic: gather context → call the model → model requests actions (tools) → execute actions → feed results back → repeat until done. Chat is the degenerate case (zero tool iterations); Claude Code and the Agent SDK are elaborate productions of the same loop.
The loop reframes engineering questions: reliability = what happens on a bad iteration; cost = tokens × iterations; latency = iterations × round-trips. Optimizing an agent means optimizing the loop, not just the prompt.

Capabilities tour

Tool use — declare JSON-schema tools; Claude decides when to call them and returns structured tool_use blocks; you execute and return results (tool-use).
Extended thinking — a reasoning budget the model spends before answering; enables harder multi-step problems at extra token cost (extended-thinking).
Built-in tools — Anthropic-provided tools (e.g., web search, code execution) that run server-side, so you get capability without hosting the execution.
Skills — packaged instructions + resources the model loads on demand for specific task types (agent-skills).
MCP — the open protocol for connecting Claude to external tools and data sources; write one server, use it from every Claude surface (mcp-overview).
Context management — techniques for keeping long agentic sessions inside the context window: compaction, summarization, state externalization (context-management).

Managed agents vs self-hosted

Managed agents — Anthropic server-hosted agents that run the agent loop on Anthropic's infrastructure inside a managed sandbox (isolated execution environment for code and file operations). You supply the task and configuration; Anthropic supplies the runtime, isolation, and scaling.
Self-hosted agents — you run the loop yourself via the agent-sdk or a custom implementation: maximum control over tools, state, and security posture, but the sandboxing, orchestration, and ops burden are yours.

Dimension	Managed agents	Self-hosted (Agent SDK / custom)
Infrastructure	Anthropic-run	Yours
Sandboxing	Managed sandbox included	You build/choose isolation
Control & customization	Configuration-level	Full code-level
Time to production	Fastest	Slower, more flexible
Best for	Standard agentic tasks, quick deployment	Deep integration, custom tool ecosystems, strict environments

Building with Claude Code

The course positions claude-code-overview as both a product and a reference implementation: CLAUDE.md for persistent project context, skills and slash commands for repeatable workflows, hooks for deterministic guardrails, and headless mode for CI/CD — all patterns you can replicate in your own agents.

Costs and limits

Tokens — the billing unit; input and output priced separately, thinking tokens billed as output.
Prompt caching — mark stable prompt prefixes for server-side caching; the single biggest cost/latency lever for repeated-prefix workloads (prompt-caching).
Batch API — 50% discount for non-urgent bulk jobs (batch-api).
Rate limits — per-tier request and token throughput caps; production designs need backoff and, at scale, workload tiering across models.