The CCA course

Workflows vs Agents: Choosing the Right Level of Autonomy

Learn Anthropic's workflow/agent distinction and the 'start simple' principle that decides when a single agent or even no agent is the right call.

The Agent Loop: Gather Context, Act, Verify, Repeat

Master the core loop that makes a system an agent, why verification is the highest-leverage step, and how good tool interfaces (the ACI) drive reliability.

Orchestrator-Worker and Subagents: Context Isolation

Design multi-agent systems the Anthropic way: an orchestrator that decomposes and synthesizes, subagents with isolated context windows, and the token-cost tradeoff that comes with them.

Routing, Parallelization, and Evaluator-Optimizer Loops

Learn the three workflow patterns Anthropic names alongside chaining: route inputs to specialized paths, parallelize independent work (sectioning and voting), and refine with an evaluator-optimizer loop.

Error Recovery, Stop Conditions, and Guardrails

Make agents fail gracefully: surface tool errors back to the model, bound retries with backoff and circuit breakers, set stop conditions and budgets, and add human checkpoints before high-stakes actions.

Project Memory with CLAUDE.md

Configure the three CLAUDE.md memory layers, compose them with @imports, and know what memory can and cannot enforce.

Hooks and the settings.json Event Model

Wire deterministic, harness-run hooks to lifecycle events, read their stdin JSON, and control behavior with exit codes and matchers.

Skills, Slash Commands, and Subagents

Extend Claude Code with description-driven skills, argument-aware slash commands, and context-isolated subagents, and know when to reach for each.

Permissions, MCP Servers, and Output Styles

Govern Claude Code with settings precedence and permission rules, configure project MCP servers safely, and adapt behavior with output styles.

Prompt Foundations: System Prompts, Roles, and Being Clear and Direct

Set durable behavior with the system prompt and role prompting, then write instructions that are explicit, positive, and context-rich.

Structuring Inputs: XML Tags and Multishot Examples

Delimit data, instructions, and examples with XML tags, separate untrusted data from commands, and teach format by demonstration with few-shot examples.

Steering Reasoning and Output Format: Chain-of-Thought, Extended Thinking, and Format Control

Decide when to invest in reasoning, distinguish prompted chain-of-thought from the extended thinking feature, and steer output format and length with direct instructions, Structured Outputs, and temperature.

Reliable Structured Output: Tools, Structured Outputs, and Grounded JSON

Get schema-valid JSON with forced/strict tool use and Structured Outputs, keep reasoning out of the JSON, and ground answers in source documents to cut hallucination.

The Tool Use Loop: input_schema, tool_use, and tool_result

Master the request/response mechanics of the Anthropic Messages API tool-use loop and tool_choice modes.

Designing Effective Tools: Descriptions, Schemas, and Error Handling

Write tool descriptions and JSON Schemas that prevent misuse, and return errors the model can recover from.

MCP Architecture and the Three Server Primitives

Understand the host/client/server model and who controls MCP Tools, Resources, and Prompts.

MCP Transports, Lifecycle, and Advanced Capabilities

Choose the right MCP transport and reason about initialization, sampling, and roots.

The Context Window: Budgeting a Finite Resource

Understand the size of Claude's context window, how to count tokens before you send, and why packing it full hurts reliability.

Prompt Caching: Make the Stable Prefix Cheap

Master cache_control breakpoints, TTL, prefix ordering, and the economics that make caching pay off across agent turns.

Reliability Patterns: RAG, Compaction, Citations, Batches, and Backoff

Pick the right architectural pattern for long-running, large-corpus, and high-volume workloads, plus the retry and streaming patterns that keep apps reliable.