Anthropic Developer: Foundations

Real applications hold conversations. You manage message history, set system prompts and temperature, stream replies to a user interface, and handle long exchanges without losing the thread.

• Multi-turn conversations and message history
• System prompts and persona
• Temperature and sampling controls
• Streaming responses
• Managing history length
• Stop sequences and output limits

You build A streaming chat app with a system prompt and managed history.

A prompt that works once is not a prompt that works always. You write clear, direct instructions, structure them with XML tags, add examples, and get structured data back that your code can parse.

• Clear, direct and specific instructions
• XML tags for structure
• Few-shot examples
• Getting JSON and other structured output
• Handling bad or refused output
• Prompts as versioned code

You build A prompt that extracts structured data from messy text, with parsing and error handling.

You cannot improve what you do not measure. You build test sets, run prompts across them, and grade the results with code and with a model, so that changes are judged by evidence.

• Building a test dataset
• Running a prompt over a dataset
• Code-based grading
• Model-based grading
• Comparing prompt versions
• Avoiding overfitting to the test set

You build An evaluation script that scores two versions of a prompt on the same test set.

Tool use connects Claude to the world. You define tools with schemas, handle tool-use blocks, return results, chain several calls in a conversation, and use built-in tools where they fit.

• Writing tool schemas and descriptions
• Handling tool-use blocks and returning results
• Multi-turn tool conversations
• Parallel tool calls
• Tool errors and validation
• Built-in tools such as web search and text editing

You build A Claude assistant with three tools that completes a multi-step request.

The API offers more than text in and text out. You add extended thinking for harder problems, send images and PDFs, ask for citations, cache repeated context, and upload files for reuse.

• Extended thinking and its budget
• Images and PDF input
• Citations
• Prompt caching
• The Files API
• Batch processing for bulk work

You build A document question-answering tool that uses PDF input, citations and caching.

Claude only knows what you show it. You build simple retrieval over your documents and expose tools and data through the Model Context Protocol, so applications can connect to many systems the same way.

• Chunking and embeddings
• Keyword and semantic search together
• Building a retrieval step into a prompt
• MCP servers, clients and the three primitives
• Connecting an app to an existing MCP server
• Choosing between custom tools and MCP

You build A question-answering app over your own documents, with one MCP server.

An agent loops until its task is done. You write the loop by hand, use the SDK’s helpers, choose between workflows and agents, and manage context so that long tasks stay on track and affordable.

• The agent loop
• Writing the loop by hand
• Using the SDK’s tool runner
• Workflows: chaining, routing and parallelization
• When a task needs a true agent
• Context management for long tasks
• Stopping conditions and safety limits

You build A working agent that completes a multi-step task using tools, with a log of each step.

A working agent is not yet a shipped one. You add error handling, observability, cost and rate controls, guard against misuse and prompt injection, and test the system before users arrive.

• Retries, timeouts and fallbacks
• Logging and tracing
• Cost and rate-limit controls
• Prompt injection and misuse
• Testing agents before release
• Deployment and configuration

You build A production-ready version of your agent, with logs, limits and a test suite.

Build a complete feature end to end. You choose the pattern, write prompts and tools, evaluate the result, add safeguards and observability, and explain your decisions as you would in a code review.

• Choosing a feature and its design
• Implementing tools and prompts
• Evaluating and improving
• Hardening for production
• Presenting the code and decisions

You build A deployed agent feature with evaluations, safeguards and documentation.