1.2 Study Map
Key Takeaways
- Build before agents: start with a single Claude API call, then add retrieval, structured output, tools, and evaluation in that order.
- Anthropic's five workflow patterns - prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer - are core exam knowledge.
- Choose a workflow for predictable tasks and reserve agents for genuinely open-ended ones; autonomy is a cost, not a default.
- Practice real Claude Code and Model Context Protocol (MCP) setup, plus least-privilege tool design, not just definitions.
- Use a four-week plan that ends in an evaluated agent prototype, writing a design note for each project.
Build a Practical Prep Plan
The fastest way to learn Claude architecture is to build small production-style systems, not to read definitions. Anthropic's own guidance in Building Effective Agents is blunt: start by calling the LLM API directly, and add complexity only when a measurable benefit justifies it. So do not open your study with a large autonomous agent. Begin with a single call, add retrieval, add structured output, then add tools and evaluation only when the use case needs them.
The spine of the exam is the distinction between two system types:
- A workflow is a system where Claude and tools are orchestrated through predefined code paths the developer controls.
- An agent is a system where Claude dynamically directs its own process and tool usage, deciding the steps at runtime.
Workflows are predictable, cheaper, and easier to test; agents are flexible but harder to bound. The exam repeatedly asks you to choose between them, and the safe default for predictable tasks is the workflow.
The Five Workflow Patterns (Memorize These)
Anthropic defines five composable workflow patterns. Knowing when each applies is core exam knowledge.
| Pattern | What it does | Use when |
|---|---|---|
| Prompt chaining | Splits a task into sequential steps; each call uses the prior output | The task decomposes cleanly into fixed stages (e.g., outline then draft) |
| Routing | Classifies the input, then sends it to a specialized prompt/handler | Distinct input categories need different handling (e.g., billing vs. technical tickets) |
| Parallelization | Runs subtasks concurrently, then aggregates (sectioning or voting) | Subtasks are independent, or you want multiple opinions for reliability |
| Orchestrator-workers | A lead model breaks work into subtasks and delegates dynamically | The subtasks are not known in advance and must be planned at runtime |
| Evaluator-optimizer | One model generates, another critiques, looping to improve | You have clear evaluation criteria and iterative refinement helps |
A frequent trap: confusing routing (a classification gate that picks one path) with orchestrator-workers (a planner that spawns several subtasks). Routing is fixed-path; orchestration is dynamic decomposition.
Four-Week Foundation Plan
| Week | Focus | Deliverable |
|---|---|---|
| 1 | API and prompts | Reliable single-call workflow with a clear system prompt |
| 2 | Tools and schemas | Validated structured output (JSON schema, retries) |
| 3 | MCP and Claude Code | Local integration via the Model Context Protocol (MCP) |
| 4 | Agents and reliability | Evaluated agent prototype with bounded turns and evals |
MCP is the open standard that lets Claude connect to external context and tools through a consistent server interface; Claude Code is Anthropic's agentic command-line tool that uses these capabilities for developer workflows. In Week 3, actually stand up an MCP server and connect it, rather than only reading about it.
Practice Project Ideas
Build four small systems, each forcing a real design decision:
- A support triage router (routing pattern, classifies tickets).
- A document Q&A flow with citations (retrieval plus structured output).
- A tool-calling data lookup (least-privilege tool design).
- A bounded agent with a hard turn limit and a fallback path.
For each, write a one-page design note: the pattern chosen and why, the tool permissions granted, the validation method, the fallback behavior, and how you would detect a regression. This habit mirrors how the exam reasons.
Evidence of Readiness
You are ready when you can explain, without notes, why a workflow is safer than an agent for predictable tasks, when routing beats prompt chaining, how MCP exposes external context, why least privilege limits blast radius, and how evals catch regressions before users do.
How to Decide: Workflow or Agent
The single most common decision on the exam is whether a scenario calls for an orchestrated workflow or a dynamic agent. Use this decision aid rather than instinct:
| Signal in the scenario | Favors a workflow | Favors an agent |
|---|---|---|
| The steps are known in advance | Yes | No |
| The number of steps varies per input | No | Yes |
| Cost-of-error is high / regulated | Yes (easier to bound and audit) | Only with strict guardrails |
| The task needs open-ended exploration | No | Yes |
| You need predictable cost and latency | Yes | No |
Anthropic's guidance is to prefer the simplest pattern that works, escalating from a single call to a workflow to an agent only when complexity is justified by a real gain. On the exam, an agent answer is correct when the task genuinely cannot be expressed as a fixed sequence; otherwise the workflow answer wins.
Reliability, Cost, and Safety as First-Class Goals
Foundations is not only about getting an answer - it is about getting a dependable one in production. Build these habits into every practice project:
- Bound the agent. Set a maximum number of turns or tool calls so a stuck loop cannot run up cost or take destructive action.
- Apply least privilege. Grant each tool the narrowest permission that completes the job; a read-only lookup tool should never carry write or delete scope.
- Validate outputs. Use schema validation and retries for structured output instead of trusting free text.
- Evaluate before and after changes. Maintain a small evaluation set so a model upgrade, prompt edit, or new tool integration cannot silently regress quality. Anthropic frames evals as the safety net that catches problems before real users do.
- Plan a fallback. Define what happens when a tool errors, a response fails validation, or confidence is low - escalate to a human, return a safe default, or retry with a stronger model.
Writing these decisions down as design notes is the exact reasoning the certification rewards, and it doubles as your revision material.
An incoming customer message must be classified as 'billing', 'technical', or 'sales', then handled by a prompt specialized for that category. Which workflow pattern fits best?
Following Anthropic's guidance, what is the best first project when preparing for CCA-F?