On-site preparation roadmap

Domain-by-domain focus (D1-D5)

Use these as your mastery checkpoints before you sit the full simulation.

Recommended study sequence

Follow this loop until your score and reasoning consistency stabilize.

Exam-day strategy

Target disciplined tradeoffs under time pressure, not just recall.

Topic library

Everything below lives on this site. Use the home page cards to jump here, or open a section directly.

Building effective agents

Production agent design balances autonomy with control: decompose work, preserve shared context, and enforce policy before side effects.

Core patterns

• Multi-concern requests: Split into distinct work items, investigate in parallel with shared customer or case context, then synthesize one reply.
• Ordering and prerequisites: Prompts alone cannot guarantee tool order. Use programmatic gates (for example block a refund tool until identity is verified).
• Partial failure: Synthesize what succeeded, state what failed and why, and offer escalation for unresolved items.
• Escalation: Honor explicit human requests immediately. Escalate when policy is silent or ambiguous, not only when the case is “hard.”

Multi-agent coordination

• Pass structured claim-to-source mappings between agents so synthesis preserves citations and avoids redundant phrasing.
• Partition research scope across subagents to reduce duplicate search results.
• Route simple vs deep queries differently to meet latency SLAs.

Claude Agent SDK

The SDK is how you orchestrate subagents, hooks, and tool use with explicit control flow.

What to internalize

• Subagents: Isolated context; findings are not automatically visible to siblings. Pass outputs explicitly in the next prompt.
• Explore-style isolation: Run verbose discovery in a subagent so the coordinator keeps a summary, not thousands of lines.
• Hooks: Pre-execution hooks can block or reshape tool calls; post-hooks can normalize outputs.
• tool_choice: Use forced tool selection when a specific tool must run first; any only guarantees some tool call, not which one.
• fork_session: Branch from a shared baseline to compare strategies (not for backups or parallel unrelated agents).

Claude Code

Configuration, commands, and skills must be scoped so the right rules load for the right files and users.

Memory and rules

• ~/.claude/ is user-local and not shared by git. Team standards belong in the project (for example .claude/ or project CLAUDE.md).
• Path-scoped rules: Use glob patterns so Terraform, API, and frontend rules load only when editing matching paths.
• Skills: Use context: fork when a skill would flood the main session. Use argument-hint when parameters are required.
• Plan mode: Prefer for large migrations with multiple valid approaches and cross-cutting dependencies.

CLI and CI

• Structured CI output: use machine-readable JSON with a schema, not “please respond in JSON” in free text.
• Project-level CLAUDE.md loads in CI when present in the repo; user-only paths do not.

Model Context Protocol (MCP)

MCP connects tools and data to agents; design shapes reliability and token use.

Design principles

• Descriptions: Differentiate similar tools clearly; overlapping schemas cause misrouting.
• Verbose outputs: Trim or map fields before they accumulate in context across turns.
• Normalization: Use hooks to unify timestamps, IDs, and formats before the model reads them.
• Large tool sets: Narrow tools per role or expose catalogs as resources so agents browse less blindly.
• Community vs custom: Prefer maintained servers for generic integrations; build custom servers for internal workflows.

Message Batches API

Asynchronous batch processing trades latency for cost and throughput.

• Batches can take up to about 24 hours; plan submission frequency so deadlines still fit your SLA.
• Use custom_id to correlate requests and to resubmit only failed items after fixing root causes.
• Do not resubmit the whole batch when a subset fails for different reasons (for example context limit vs bad input).

Prompt engineering and structured output

Schemas constrain shape, not meaning; pair them with validation and review workflows.

• Semantic errors: Values in wrong fields need business-rule checks and retry-with-error-feedback, not just stricter JSON types.
• Required fields: Required keys can cause fabrication when data is missing; prefer optional or nullable fields when absence is valid.
• Enums and unknowns: Use other plus a detail string for extensibility instead of endless enum patches.
• Few-shot coverage: Match document structures in examples; otherwise you get empty or null fields on unseen layouts.
• Rendering: Prefer tables for numeric data, prose for narrative, lists for technical findings—uniform markdown everywhere often hurts clarity.
• Reviews: Define explicit severity rubrics with examples; separate reviewer from author session to reduce self-approval bias.

Exam outline summary

The CCA Foundations exam weights domains to reflect solution architecture for production Claude applications. This site’s mock exams follow the same five domains and six scenario families.

• Format (as simulated here): Proctored mode uses 60 questions in 120 minutes with scaled scoring; passing is 720 on a 200–1000 scale.
• Domains: D1 Agentic architecture and orchestration; D2 Tool design and MCP; D3 Claude Code configuration and workflows; D4 Prompt engineering and structured output; D5 Context management and reliability.
• Study approach: Pair domain-filtered practice with this topic library, then validate under time with the full proctored simulation.

Certification and the live exam

The live proctored certification is offered through Anthropic’s official training and exam flow (for example via their access and scheduling portal). This prep site is unofficial: use it to practice; register and schedule through the official program when you are ready.

No outbound links are required to study here—the topic sections above are sufficient for exam-style reasoning alongside the mock exams.

External links (official sources)

Optional references if you want to cross-check the on-site material against source documentation.