This class prepares solution architects and engineers for the Claude Certified Architect – Foundations (CCAR-F) exam. A Claude Certified Architect designs and ships production applications with Claude, making sound tradeoff decisions across the Claude API, the Claude Agent SDK, Claude Code and the Model Context Protocol (MCP). The exam tests that judgment through realistic scenarios: customer support agents, multi-agent research pipelines, Claude Code in CI/CD, developer productivity tools and structured data extraction.

This Track Includes:

Building Production Applications with Claude – 5 Days

Duration

5 Days (40 hours: about 50% hands-on labs)

Description

This course teaches you to build agentic loops driven by stop_reason, orchestrate coordinator–subagent systems with the Agent SDK, and enforce business rules with hooks instead of prompts. You will design MCP tools with clear descriptions and structured errors, and configure Claude Code for a team with CLAUDE.md hierarchies, path-scoped rules, skills and slash commands.

You will also run Claude Code headless in CI/CD, produce schema-guaranteed output with tool_use and JSON schemas, and choose between synchronous and Message Batches processing. The final days cover context management, escalation design, error propagation, human review routing and source provenance. Every module ends with a lab and exam-style scenario questions mapped to the official CCAR-F blueprint.

Objectives

This course teaches participants the following skills:

  • Implement agentic loops that continue on “tool_use” and stop on “end_turn”, avoiding text-parsing and iteration-cap anti-patterns
  • Design hub-and-spoke multi-agent systems where a coordinator decomposes tasks, spawns parallel subagents via the Task tool and aggregates results
  • Pass context explicitly to subagents using structured data that preserves source attribution
  • Enforce critical workflow rules with programmatic prerequisites and Agent SDK hooks (PreToolUse/PostToolUse) rather than prompt instructions
  • Manage sessions with –resume, fork_session and summary-based restarts
  • Write tool descriptions that remove ambiguity between similar tools, and split or rename tools to eliminate overlap
  • Return structured MCP errors (isError, errorCategory, isRetryable) and distinguish access failures from valid empty results
  • Scope tools per agent and configure tool_choice (“auto”, “any”, forced)
  • Configure MCP servers at project scope (.mcp.json with environment variable expansion) and user scope (~/.claude.json), and expose MCP resources
  • Select the right built-in tool (Read, Write, Edit, Bash, Grep, Glob) for each exploration and editing task
  • Organize CLAUDE.md across user, project and directory levels, with @import and .claude/rules/ path-scoped rules
  • Build team slash commands and skills using context: fork, allowed-tools and argument-hint
  • Decide between plan mode and direct execution, and use the Explore subagent to protect context
  • Run Claude Code in CI with -p, –output-format json and –json-schema, and use independent review instances
  • Reduce false positives with explicit criteria and 2–4 targeted few-shot examples
  • Guarantee structured output with tool_use and JSON schemas, design nullable and enum fields, and build validation–retry loops
  • Choose the Message Batches API for latency-tolerant work and handle failures by custom_id
  • Preserve critical facts across long sessions with case-facts blocks, trimmed tool outputs, scratchpads and /compact
  • Design escalation criteria, structured error propagation, confidence-calibrated human review and claim–source provenance

Course Outline

The course includes presentations, demonstrations, hands-on labs and scenario-based practice questions. Twelve modules cover all 30 task statements across the five exam domains; each module lists the blueprint task statements it maps to.

ModuleExam domainTask statementsDayTime
1. The Claude Platform for ArchitectsFoundation for all domains—12.5 h
2. Agentic Loops and Workflow EnforcementD1 Agentic Architecture1.1, 1.4, 1.514 h
3. Multi-Agent Orchestration and SessionsD1 Agentic Architecture1.2, 1.3, 1.6, 1.723.5 h
4. Tool Interface Design and Structured ErrorsD2 Tool Design & MCP2.1, 2.2, 2.323 h
5. MCP Integration and Built-in ToolsD2 Tool Design & MCP2.4, 2.532.5 h
6. Configuring Claude Code for TeamsD3 Claude Code3.1, 3.2, 3.332 h
7. Claude Code Workflows and CI/CDD3 Claude Code3.4, 3.5, 3.632 h
8. Prompt Engineering for Precision and ReviewD4 Prompt Engineering4.1, 4.2, 4.642.5 h
9. Structured Output, Validation and Batch ProcessingD4 Prompt Engineering4.3, 4.4, 4.544 h
10. Context Management in Long SessionsD5 Context & Reliability5.1, 5.452 h
11. Reliability: Escalation, Errors, Review and ProvenanceD5 Context & Reliability5.2, 5.3, 5.5, 5.652.5 h
12. Exam Readiness and CapstoneAll domainsAll52 h

Module 1: The Claude Platform for Architects

  • Map the four technologies on the exam: Claude API, Claude Agent SDK, Claude Code and MCP, and where each fits in a production design
  • Explain the Messages API request/response cycle, system prompts, max_tokens and stop_reason values
  • Describe tool use end to end: tool definitions, tool_use blocks, tool_result blocks
  • Tour the six exam scenarios and the five domains with their weights
  • Lab 1: Make your first tool-calling request and inspect every field of the response

Module 2: Agentic Loops and Workflow Enforcement

  • Implement the agentic loop: send, inspect stop_reason, execute tools, append results, repeat
  • Contrast model-driven tool selection with pre-configured decision trees
  • Avoid loop anti-patterns: parsing natural language for completion, iteration caps as the main stop, checking for text content
  • Explain why prompt instructions have a non-zero failure rate when compliance must be deterministic
  • Build programmatic prerequisites, e.g. block process_refund until get_customer returns a verified ID
  • Use hooks to intercept outgoing tool calls (block refunds over $500, redirect to escalation) and PostToolUse hooks to normalize timestamps and status codes
  • Decompose multi-concern requests and compile structured handoff summaries for human agents
  • Lab 2: Build a customer support agent (get_customer, lookup_order, process_refund, escalate_to_human) with a refund-threshold hook

Module 3: Multi-Agent Orchestration and Sessions

  • Design hub-and-spoke systems where the coordinator owns decomposition, routing, error handling and aggregation
  • Spawn subagents with the Task tool; include “Task” in allowedTools; configure AgentDefinition descriptions, prompts and tool restrictions
  • Pass complete prior findings explicitly, since subagents do not inherit parent context
  • Emit multiple Task calls in one response for parallel execution
  • Partition scope to avoid duplication, and spot overly narrow decomposition
  • Build iterative refinement loops: evaluate synthesis for gaps, re-delegate, re-synthesize
  • Choose prompt chaining for predictable reviews versus dynamic decomposition for open-ended investigation
  • Manage sessions with –resume <name>, fork_session, and fresh starts with injected summaries when tool results are stale
  • Lab 3: Build a coordinator with web-search and document-analysis subagents running in parallel

Module 4: Tool Interface Design and Structured Errors

  • Treat tool descriptions as the primary selection mechanism: inputs, example queries, edge cases, boundaries
  • Fix misrouting by renaming and splitting overlapping tools (e.g. analyze_document → extract_data_points, summarize_content, verify_claim_against_source)
  • Review system prompts for keyword-sensitive wording that overrides tool descriptions
  • Return structured errors with isError, errorCategory (transient, validation, business, permission), isRetryable and readable messages
  • Distinguish access failures from valid empty results
  • Scope tools per agent (4–5, not 18), add narrow cross-role tools such as verify_fact, and set tool_choice auto, any or forced
  • Lab 4: Redesign an ambiguous tool set and measure selection accuracy before and after

Module 5: MCP Integration and Built-in Tools

  • Configure shared servers in project .mcp.json with ${ENV_VAR} expansion, and personal servers in ~/.claude.json
  • Explain that tools from all configured servers are discovered at connection time and available together
  • Expose content catalogs (schemas, issue summaries, doc trees) as MCP resources to cut exploratory calls
  • Prefer community servers for standard integrations; build custom servers for team-specific workflows
  • Choose Grep for content, Glob for paths, Read/Write for whole files and Edit for unique-anchor changes, with Read + Write as fallback
  • Explore codebases incrementally: Grep for entry points, Read to trace imports
  • Lab 5: Connect a project MCP server and a personal one; explore a legacy codebase with built-in tools

Module 6: Configuring Claude Code for Teams

  • Apply the CLAUDE.md hierarchy: user (~/.claude/CLAUDE.md), project and subdirectory levels
  • Diagnose instructions missing for teammates because they live at user level; verify loaded files with /memory
  • Keep configuration modular with @import and topic files in .claude/rules/
  • Write path-scoped rules with YAML paths globs (e.g. /*.test.tsx, terraform//*)
  • Create project slash commands in .claude/commands/ and personal ones in ~/.claude/commands/
  • Build skills in .claude/skills/ with SKILL.md frontmatter: context: fork, allowed-tools, argument-hint
  • Choose skills for on-demand workflows versus CLAUDE.md for always-on standards
  • Lab 6: Configure a repository with CLAUDE.md, path-scoped rules, a /review command and a forked skill

Module 7: Claude Code Workflows and CI/CD

  • Choose plan mode for architectural, multi-file or multi-approach work and direct execution for well-scoped fixes
  • Use the Explore subagent to isolate verbose discovery
  • Refine iteratively with input/output examples, test-driven iteration and the interview pattern
  • Decide when to send interacting issues together versus fixing independent issues one by one
  • Run Claude Code headless with -p, and produce structured findings with –output-format json and –json-schema
  • Use an independent review instance instead of self-review; pass prior findings to report only new issues; supply existing tests to avoid duplicates
  • Lab 7: Add an automated PR review and test-generation job to a CI pipeline

Module 8: Prompt Engineering for Precision and Review

  • Replace vague instructions (“be conservative”) with explicit categorical criteria
  • Understand how high false-positive categories erode developer trust, and temporarily disable them
  • Define severity levels with concrete code examples
  • Write 2–4 few-shot examples that show reasoning for ambiguous cases and the exact output format
  • Use few-shot examples to reduce extraction hallucination across varied document structures
  • Split large reviews into per-file passes plus a cross-file integration pass; route findings by self-reported confidence
  • Lab 8: Tune a code-review prompt to cut false positives without losing real bugs

Module 9: Structured Output, Validation and Batch Processing

  • Define extraction tools with JSON schemas and read results from the tool_use block
  • Use tool_choice “any” when the document type is unknown and forced selection to order steps
  • Design schemas with nullable fields, “unclear” enums and “other” + detail patterns
  • Separate syntax errors (removed by tool use) from semantic errors (totals that do not sum)
  • Build validation–retry loops with specific error feedback, and recognize when retry cannot help
  • Add self-check fields: calculated_total vs stated_total, conflict_detected, detected_pattern
  • Use the Message Batches API (50% cost, up to 24 h, no mid-request tool calls) for latency-tolerant work; correlate by custom_id; resubmit only failures
  • Lab 9: Build an invoice extraction pipeline with Pydantic validation and a 100-document batch run

Module 10: Context Management in Long Sessions

  • Recognize progressive-summarization loss of numbers, dates and customer expectations
  • Mitigate the lost-in-the-middle effect with key findings first and clear section headers
  • Keep a persistent case-facts block outside summarized history
  • Trim verbose tool outputs to relevant fields before they accumulate
  • Use scratchpad files, subagent delegation, phase summaries and /compact in large codebase exploration
  • Design crash recovery with exported agent state and a coordinator manifest
  • Lab 10: Run a long multi-issue support session and keep every amount and order ID accurate

Module 11: Reliability: Escalation, Errors, Review and Provenance

  • Set escalation triggers: explicit human requests, policy gaps or exceptions, no progress
  • Explain why sentiment and self-reported confidence are poor escalation signals; ask for more identifiers on multiple matches
  • Propagate structured errors (failure type, query attempted, partial results, alternatives); avoid silent suppression and whole-workflow termination
  • Annotate synthesis output with coverage gaps
  • Validate accuracy by document type and field; use stratified sampling and calibrated field-level confidence for review routing
  • Preserve claim–source mappings, annotate conflicting statistics, and carry publication dates
  • Lab 11: Simulate a subagent timeout and conflicting sources; produce a report with provenance and coverage notes

Module 12: Exam Readiness and Capstone

  • Walk through all six scenarios and the reasoning patterns behind correct answers
  • Practice spotting the “proportionate first step” versus over-engineered options
  • Review the twelve official sample questions in depth
  • Take a timed 60-question practice exam (120 minutes) with domain-level score feedback
  • Capstone: Present an architecture for one scenario, defending each tradeoff

Day-by-Day Agenda

Each 8-hour day has 6.5 hours of modules and labs plus a 1.5-hour scenario clinic on that day’s domains.

DayThemeModulesLabsScenario clinic
1Foundations and agentic loops1, 2Lab 1, Lab 2Customer Support Resolution Agent
2Multi-agent systems and tool design3, 4Lab 3, Lab 4Multi-Agent Research System
3MCP and Claude Code5, 6, 7Lab 5, Lab 6, Lab 7Code Generation with Claude Code; Claude Code for CI
4Prompting and structured output8, 9Lab 8, Lab 9Structured Data Extraction
5Reliability and exam readiness10, 11, 12Lab 10, Lab 11, CapstoneDeveloper Productivity with Claude; full practice exam

Who Should Attend

This class is intended for the following job roles:

  • Solution architects who design and implement production applications with Claude
  • AI, ML and software engineers building agentic applications with the Claude Agent SDK
  • Platform and DevOps engineers integrating Claude Code into team workflows and CI/CD pipelines
  • Data engineers building document extraction and structured-output pipelines with Claude
  • Technical leads and consultants at Anthropic partner organizations preparing for the CCAR-F credential

Prerequisites

To get the most out of this course, participants should have:

  • Working proficiency in Python or TypeScript, including calling REST APIs and handling JSON
  • Familiarity with Git, a command-line shell and a CI/CD system (e.g. GitHub Actions)
  • Basic understanding of large language models and prompting
  • Recommended: some hands-on time with the Claude API or Claude Code. The exam guide targets candidates with 6+ months of practical experience; this course compresses that ramp-up

Certification

Claude Certified Architect – Foundations (exam code CCAR-F)

Exam detailValue
Items60 multiple-choice and multiple-response
Structure4 scenarios drawn at random from a bank of 6
Time limit120 minutes
Passing score720 scaled (range 100–1,000)
DeliveryPearson VUE, online proctored or test center
Exam fee$125 USD per attempt
Validity12 months; free online renewal if renewed on time
RegistrationAnthropic Partner Academy, then schedule with Pearson VUE
RetakesWait 14, 30, then 90 days; max 4 attempts in 12 months

 

CCAR-F Exam Guide

CCAR-F Exam Guide v1.0, Section 4 blueprint · item counts approximate

Course time follows the same weighting: Domain 1 gets two full modules on Days 1–2, and every domain gets its own lab and scenario clinic.

Course Schedule

Proposed weekday batches run Monday to Friday, one per month; a weekend batch covers the same 40 hours over five consecutive Saturdays. These dates are a draft for you to confirm.

BatchFormatDates
Nov 2026Weekday (Mon–Fri)16–20 Nov 2026
Dec 2026Weekday (Mon–Fri)14–18 Dec 2026
Jan 2027Weekday (Mon–Fri)18–22 Jan 2027
Feb 2027Weekday (Mon–Fri)15–19 Feb 2027
Mar 2027Weekday (Mon–Fri)15–19 Mar 2027
Apr 2027Weekday (Mon–Fri)19–23 Apr 2027
May 2027Weekday (Mon–Fri)17–21 May 2027
Jun 2027Weekday (Mon–Fri)14–18 Jun 2027
Jan–Feb 2027Weekend (5 Saturdays)9, 16, 23, 30 Jan and 6 Feb 2027
Apr–May 2027Weekend (5 Saturdays)3, 10, 17, 24 Apr and 1 May 2027

Open question: delivery mode (live online, classroom or both) and time zone for live sessions.

Course Fees

The course fee is yours to set; the exam fee is fixed by Anthropic at $125 USD per attempt and is paid separately at registration.

Fee itemAmountIncludes
Course fee – individual (self-sponsored)To be set5 days of instruction, 11 labs + capstone, lab code, slides, 60-question practice exam
Course fee – corporate (company-sponsored)To be setSame as individual, plus private batch option
Early-bird / group discountTo be setOptional: e.g. 3+ seats from one company
CCAR-F exam fee$125 USD per attemptPaid via Anthropic Partner Academy; partner-tier discounts apply at checkout

Open question: course fee currency (INR, USD or both) and whether the exam fee is bundled.

FAQs

Do I need my own Claude API access for the labs?
Yes. Each participant needs a Claude API key and Claude Code installed; lab usage costs are small but should be stated in the joining instructions.

Does the course include the exam voucher?
Not by default. Candidates register and pay $125 USD through the Anthropic Partner Academy and schedule with Pearson VUE.

How long is the credential valid?
12 months. On-time renewal is a free, non-proctored assessment; a lapsed credential means retaking the full exam.

What is not covered on the exam?
Fine-tuning, API billing and authentication, MCP server hosting, computer use, vision, streaming, rate limits, embeddings and prompt caching internals are out of scope, so the course does not teach them.

What if I fail?
You can retake after 14 days, then 30, then 90, up to 4 attempts in 12 months; each attempt carries the exam fee.

Sources

    Book Now