✦ Radian CCA-F · Fully Self-Contained
CCA Foundations
Exam Portal
Everything you need to pass the Claude Certified Architect — Foundations exam — fully integrated in a single file. Reference guides, anti-patterns, FAQ, four quiz formats, flashcards, decision trees, and a study plan.
720Pass Score
4/6Scenarios
27%D1 Weight
5Domains
0ptsWrong Penalty
Domain Weightings
D1Agentic Architecture & Orchestration27%
D3Claude Code Config & Workflows20%
D4Prompt Engineering & Structured Output20%
D2Tool Design & MCP Integration18%
D5Context Management & Reliability15%
All Study Tools
Reference
Quick Reference Guide
All 5 domains, task statements, scenario map, tool selection guide, error categories, and decision matrices — everything at a glance before exam day.
Open Guide →
Reference
Anti-Patterns Cheat Sheet
27 wrong approaches with their correct alternatives. Organized by domain with severity ratings. The patterns the exam is specifically designed to test.
Open Sheet →
Reference
FAQ
40 questions covering every tricky concept, confusable term pair, and "wait, which one is it?" moment. Searchable and filterable by topic.
Open FAQ →
Practice
Practice Quiz
25 shuffled questions across all 5 domains and all 3 question types. Live scoring, instant explanations, and per-domain breakdown at the end.
Start Quiz →
Practice
Complete Scenario Quiz
54 questions across all 6 scenarios. Filter by scenario, mode. Single answer, multi-select, and scenario-based questions with scoring.
Start Quiz →
Practice
6-Scenario Deep Drill
60 questions — 10 per scenario. Easy / Medium / Hard. Filter by scenario or question type. The most comprehensive scenario practice available.
Start Drill →
Practice
Common Mistakes Trap Drill
50 trap questions — 10 per mistake pattern. Every question is engineered to lure you into the wrong answer, then explains exactly why.
Start Traps →
Practice
Flashcards
40 cards covering every high-frequency concept. Filter by domain. Rate yourself Again / Hard / Good / Easy to track mastery across sessions.
Start Cards →
Reference
Decision Trees & Cheat Sheets
Step-by-step decision trees for the hardest judgment calls: enforcement type, escalation, Batch vs real-time API, plan mode vs direct execution.
Open Trees →
Strategy
Study Plan
Structured 2-week preparation plan with checkable tasks. Tracks your progress across all study tools from this portal.
Open Plan →
Strategy
Dos & Don'ts
Exam strategy and real-world Claude usage dos and don'ts. 5 tabs: Exam Strategy, Agentic Systems, Tools & MCP, Prompting, Context & Reliability.
Open Guide →
Practice Quiz
25 questions · All domains · All 3 question types
CCA Foundations · Practice Quiz
25 questions · All 5 domains
Question 1 of 25
Score 0
|
Correct 0
|
Wrong 0
|
Remaining 25
0%
correct
—
—
Score by Domain
6 Scenario Deep Drill
10 questions per scenario · All 3 question types · Full explanations
Claude Certified Architect · Foundations
6 Scenario
Deep Drill
10 questions per scenario — all 3 question types — with full explanations. Choose which scenarios to practice, pick your difficulty, and go.
SELECT SCENARIOS
Quiz Complete
0%
correct
0Correct
0Wrong
0Partial
0Total
0Points
0Max Points
Single-Answer
—
correct
Multi-Select
—
correct / partial
Scenario-Based
—
correct
Score by Scenario
Answer Review
Common Mistakes Drill
5 mistake patterns · 10 trap questions each · Engineered distractors
COMMON
MISTAKES
DRILL
5 mistake patterns. 10 trap questions each.
Every question is engineered to lure you into the wrong answer.
Master these and the exam's hardest distractors won't fool you.
Select mistake patterns to drill
Drill Complete
0%
correct
0Correct
0Wrong
0Partial
0Total
0Points
0Max Pts
Score by Mistake Pattern
Mastery Assessment
ANSWER REVIEW
Flashcards
40 cards · Filter by domain · Rate your mastery
Exam Prep · Tool 4 of 5
CCA Flashcards
Click card to reveal answer
Deck Complete! 🎉
Here's how you rated yourself
0
Again
0
Hard
0
Good
0
Easy
Decision Trees & Cheat Sheets
4 decision trees · API reference · Config guide · Exam traps
Decision Trees
Use these to work through the most common judgment calls on the exam. Each tree maps a diagnostic question to the correct answer strategy.
Tree 1 — Enforcement: Programmatic or Prompt?
Does this rule have financial, security, or legal consequences if violated?
YES →
Use programmatic enforcement (hook / prerequisite gate)
NO ↓
Does the rule need to apply 100% of the time (zero acceptable failure rate)?
YES →
Use programmatic enforcement
NO ↓
Is the rule complex enough that schema/hooks would be over-engineered?
YES →
Prompt instruction acceptable — monitor for failures
NO →
Prefer programmatic — more reliable at low complexity cost
Tree 2 — Escalation Decision
Did the customer explicitly say "I want a human" or equivalent?
YES →
Escalate immediately. No resolution attempt. Period.
NO ↓
Is the policy ambiguous, silent, or undefined for this request?
YES →
Escalate. Don't let the agent improvise on policy gaps.
NO ↓
Is the agent unable to make meaningful progress after genuine attempts?
YES →
Escalate with structured handoff summary.
NO →
Resolve autonomously. Acknowledge frustration if present.
Tree 3 — Batch API vs Real-Time API
Is any person or process waiting (blocked) for this result?
YES →
Real-Time API only. Batch has no latency SLA (up to 24h).
NO ↓
Does the workflow require multi-turn tool calling within a single request?
YES →
Real-Time API. Batch does not support multi-turn tool calls.
NO ↓
Is cost reduction a priority and is 24h completion acceptable?
YES →
Batch API. 50% cost savings. Use custom_id for correlation.
NO →
Real-Time API. Batch only when latency tolerance is confirmed.
Tree 4 — Plan Mode vs Direct Execution
Does the task involve multiple files AND architectural decisions?
YES →
Plan Mode. Explore before committing to prevent costly rework.
NO ↓
Are there multiple valid approaches with different tradeoffs?
YES →
Plan Mode. Evaluate options before writing code.
NO ↓
Is this a single-file, well-understood, clear-scope change?
YES →
Direct Execution. No need for exploration overhead.
UNSURE →
Default to Plan Mode. Exploration cost is low; rework is high.
API Cheat Sheet
Every API concept, value, and flag you need to know for the exam.
stop_reason Values
tool_useExecute tool → continue loopend_turnModel finished → terminatemax_tokensToken limit hit → handlestop_sequenceCustom stop string hittool_choice Options
"auto"May return text (not guaranteed tool call)"any"Must call some tool{type:"tool",name:"X"}Must call tool X specificallyMessage Batches API — Key Facts
| Property | Value | Implication |
|---|---|---|
| Cost | 50% savings | Half the price of real-time API |
| Latency SLA | None | Up to 24h — never use for blocking workflows |
| Multi-turn tool calling | Not supported | Cannot execute tools mid-request and return results |
| Request correlation | custom_id | Required to match responses to requests |
| Failure handling | By custom_id | Resubmit only failed items, not whole batch |
| Best for | Overnight / weekly jobs | Reports, audits, nightly test generation |
| Never for | Pre-merge CI checks | Developers are blocked waiting for results |
JSON Schema Design Patterns
| Pattern | When to Use | Example |
|---|---|---|
| nullable / optional field | Information may not exist in source | discount: null | number |
| enum + "other" + detail | Fixed categories but extensible | type: "refund"|"other", type_detail: string |
| calculated vs stated | Semantic validation (math checks) | calculated_total, stated_total, discrepancy_flag |
| confidence scores | Human review routing | field_confidence: 0.0–1.0 |
| claim-source mapping | Provenance in multi-source synthesis | claim, source_url, excerpt, date |
MCP Error Response Structure
| Field | Type | Values / Notes |
|---|---|---|
isError | boolean | true for all error conditions |
errorCategory | string enum | transient | validation | business | permission |
isRetryable | boolean | true only for transient; false for all others |
message | string | Human-readable description for agent/user |
| valid empty result | — | Return isError: false, data: [] — NOT an error |
Configuration Reference
Every config file, directory, and flag — location, scope, and purpose.
CLAUDE.md Hierarchy
| Location | Scope | Shared via VCS? | Use For |
|---|---|---|---|
~/.claude/CLAUDE.md | User-level | No | Personal preferences, personal tools |
.claude/CLAUDE.md or root CLAUDE.md | Project-level | Yes | Team standards, project conventions |
Subdirectory CLAUDE.md | Directory-level | Yes | Module-specific rules |
.claude/rules/*.md with glob frontmatter | File-pattern | Yes | Conventions for scattered files (e.g., all tests) |
Slash Commands & Skills
| Location | Scope | Use For |
|---|---|---|
.claude/commands/ | Project-shared | Team-wide slash commands (auto-available on clone) |
~/.claude/commands/ | Personal | Personal slash commands not shared |
.claude/skills/name/SKILL.md | Project-shared | On-demand skills with frontmatter config |
~/.claude/skills/ | Personal | Personal skill variants (won't affect teammates) |
SKILL.md Frontmatter Options
| Option | Purpose | When to Use |
|---|---|---|
context: fork | Run in isolated sub-agent context | Verbose skills (codebase analysis, brainstorming) that would pollute main session |
allowed-tools: [...] | Restrict tool access during skill | Prevent destructive actions (e.g., limit to file writes only) |
argument-hint: "..." | Prompt for required params on invocation | Skills that require a target file, component name, etc. |
Claude Code CLI Flags
| Flag | Purpose | Required For |
|---|---|---|
-p / --print | Non-interactive mode | All CI/CD pipeline invocations |
--output-format json | JSON output | Machine-parseable CI results |
--json-schema | Enforce output schema | Inline PR comment automation |
--resume <name> | Continue named session | Multi-session investigations |
/compact | Reduce context usage | Long exploration sessions nearing token limit |
/memory | View loaded memory files | Diagnosing inconsistent behavior across sessions |
MCP Server Configuration
| File | Scope | Credential Handling |
|---|---|---|
.mcp.json (project root) | All team members | Use ${ENV_VAR} expansion — never hard-code |
~/.claude.json | Current user only | Personal tokens, experimental servers |
All configured MCP servers are discovered at connection time and available simultaneously.
Scenario Map
What each scenario tests and the key traps in each. Study these patterns — exam questions are drawn directly from these scenarios.
Scenario 1 — Customer Support Resolution Agent
| Key Concept | Watch For |
|---|---|
| Tool ordering enforcement | Programmatic prerequisite, NOT prompt instruction |
| Tool description quality | Expand descriptions — don't merge tools as first fix |
| Escalation triggers | Explicit request = immediate escalation, no resolution attempt |
| Multiple customer matches | Ask for more identifiers — never guess by heuristic |
| Escalation calibration | Few-shot examples fix this — not confidence scores or sentiment |
Scenario 2 — Code Generation with Claude Code
| Key Concept | Watch For |
|---|---|
| Shared vs personal commands | .claude/commands/ = shared; ~/.claude/commands/ = personal |
| Plan mode triggers | Monolith → microservices always = plan mode |
| Path-specific rules | Glob patterns for scattered test files, not subdirectory CLAUDE.md |
| CLAUDE.md new-dev issue | If new dev doesn't get instructions → user-level not project-level |
Scenario 3 — Multi-Agent Research System
| Key Concept | Watch For |
|---|---|
| Task decomposition scope | Coverage gaps = coordinator decomposed too narrowly |
| Error propagation | Structured context → coordinator; not generic string, not empty success |
| Parallel execution | Multiple Task calls in ONE response turn — not multiple turns |
| Synthesis tool access | Scoped verify_fact tool for 85% simple case; complex = coordinator |
| Conflicting sources | Annotate both with attribution — don't pick, don't average |
Scenario 4 — Developer Productivity with Claude
| Key Concept | Watch For |
|---|---|
| Grep vs Glob | Grep = file contents; Glob = file paths — don't swap them |
| Edit fallback | Non-unique anchor → Read + Write (not retry Edit) |
| Context degradation | Scratchpad files to persist findings, not larger model |
| MCP server scope | Team server in .mcp.json; personal in ~/.claude.json |
Scenario 5 — Claude Code for CI/CD
| Key Concept | Watch For |
|---|---|
| Non-interactive mode | -p flag — not CLAUDE_HEADLESS, not --batch, not stdin redirect |
| Batch API decision | Pre-merge = real-time (blocking); overnight reports = batch |
| Multi-file review | Per-file passes + integration pass — not bigger context window |
| False positive reduction | Explicit categorical criteria — not "be conservative" |
| Independent review | New instance for review — not same session that generated code |
Scenario 6 — Structured Data Extraction
| Key Concept | Watch For |
|---|---|
| Schema design | Optional fields → nullable, not required (prevents hallucination) |
| Syntax vs semantic errors | tool_use fixes syntax; validation pass fixes semantic |
| Retry limits | Absent data can't be retried into existence |
| Aggregate accuracy | 97% overall ≠ safe to automate — check per-type and per-field |
| Few-shot for extraction | Varied document structures need examples, not just instructions |
Exam Traps & Common Wrong Answers
The distractors that catch unprepared candidates — and exactly why they're wrong.
Non-Existent Features (Always Wrong)
| Fake Option | Why It Appears | Correct Alternative |
|---|---|---|
CLAUDE_HEADLESS=true | Sounds like a reasonable env var | -p / --print flag |
--batch flag | Sounds like batch processing mode | Message Batches API (separate endpoint) |
required: true in tool_choice | Sounds like it forces tool usage | tool_choice: "any" |
.claude/config.json commands array | Sounds like a config file | .claude/commands/ directory |
parallel: true in AgentDefinition | Sounds like parallelism config | Multiple Task calls in one response |
Over-Engineered Distractors (Wrong for "First Step" Questions)
| Distractor | Why It's Wrong | Correct First Step |
|---|---|---|
| Deploy a separate routing classifier model | Requires ML infra; prompt hasn't been tried yet | Improve tool descriptions |
| Build a keyword-based pre-turn selector | Bypasses LLM's natural language understanding | Improve tool descriptions |
| Consolidate tools into one mega-tool | More effort than needed; loses specificity | Differentiate descriptions first |
| Add 3rd independent review model | Infrastructure overkill; prompt fix first | Explicit categorical criteria |
Probabilistic vs Deterministic Traps
| Trap Answer | Why Wrong | Correct Answer |
|---|---|---|
| "Add system prompt: customer verification is mandatory" | Probabilistic — LLMs have non-zero failure rate for compliance | Programmatic prerequisite gate |
| "Add few-shot showing get_customer first" | Still probabilistic for critical financial operations | Programmatic prerequisite gate |
| "Instruct Claude: do not fabricate field values" | Prompt instructions are weaker than schema constraints | Make fields nullable in JSON schema |
| "Set tool_choice: auto for guaranteed output" | auto allows text responses; not guaranteed tool call | tool_choice: "any" |
Confusable Concepts — High Exam Frequency
| Concept A | vs | Concept B | Key Difference |
|---|---|---|---|
~/.claude/CLAUDE.md (user) | vs | .claude/CLAUDE.md (project) | User = personal, not shared. Project = version-controlled, shared. |
| Syntax error (malformed JSON) | vs | Semantic error (values don't add up) | tool_use fixes syntax; validation pass fixes semantic. |
| Access failure (tool couldn't run) | vs | Valid empty result (ran, found nothing) | Access = isError:true. Empty = isError:false, data:[]. |
| fork_session (branch exploration) | vs | --resume (continue session) | fork = divergent approaches. resume = continue same thread. |
| Grep (search file contents) | vs | Glob (match file paths) | Grep = what's inside files. Glob = file names/locations. |
| context: fork (skill isolation) | vs | CLAUDE.md (always-loaded) | Skills = on-demand. CLAUDE.md = loaded every session. |
Dos & Don'ts
CCA Exam Strategy · Technical Concepts · Real-World Claude patterns
Exam-Day Strategy
Key mindset: Every question is scenario-based. The right answer is always the most reliable, production-safe, proportionate solution. Avoid over-engineered answers and probabilistic guarantees when deterministic ones are available.
✓ Do
- Read the scenario context first — it anchors which domain and tradeoffs are being tested
- Look for the root cause in the question stem before scanning options
- Prefer programmatic enforcement over prompt instructions when deterministic compliance is required
- Choose proportionate first responses — the simplest solution that solves the stated problem
- Guess if unsure — there is no penalty for wrong answers
- When two options seem correct, pick the one that addresses the root cause, not a symptom
- Treat "prompt-based solutions" as weaker than "schema/code-based solutions" for reliability questions
- Know the exact API vocabulary:
stop_reason,tool_use,end_turn,isRetryable,tool_choice - For escalation questions: customer explicitly requests human → escalate immediately, no resolution attempt
- For batch API questions: always ask "is this workflow blocking?" — if yes, batch is wrong
✗ Don't
- Choose answers that involve over-engineering (separate classifier models, keyword pre-selectors) before simpler fixes
- Assume "add more instructions to the system prompt" is the answer for deterministic compliance needs
- Conflate
tool_choice: "auto"with guaranteed tool execution — auto allows text-only responses - Choose Batch API when any person/process is waiting on the result — it has no latency SLA
- Use sentiment analysis or confidence thresholds to decide escalation — explicit request overrides everything
- Pick answers that reference non-existent features:
CLAUDE_HEADLESS,--batchflag,parallel: true - Treat "97% overall accuracy" as sufficient — always check per-type and per-field breakdown
- Swap Grep and Glob — Grep searches file contents, Glob matches file paths
Agentic Systems — Real-World Dos & Don'ts
Building production-grade agentic loops, multi-agent orchestration, and session management.
✓ Do
- Use
stop_reasonas your only loop termination signal — it's the authoritative API signal - Implement programmatic prerequisite gates for tool ordering (e.g., block
process_refunduntilget_customersucceeds) - Use
PreToolUse/PostToolUsehooks for cross-cutting concerns (logging, validation, enforcement) - Pass full structured context when spawning subagents — they don't inherit coordinator memory automatically
- Launch multiple Task tool calls in a single response turn for true parallelism
- Use
fork_sessionfor divergent exploration;--resumeto continue the same thread - Scope subagent tool access to only what that agent needs — principle of least privilege
✗ Don't
- Parse assistant message text for "task complete" to decide loop termination — brittle and unreliable
- Use arbitrary iteration caps as your primary stop mechanism — they cause premature termination
- Rely on system prompt instructions for tool ordering when financial/legal consequences exist — use programmatic gates
- Assume subagents automatically have coordinator context — always pass it explicitly
- Use multiple sequential turns to launch "parallel" tasks — this is sequential, not parallel
- Give all subagents access to all tools — creates security risk and over-complex error paths
Tool Design & MCP — Real-World Dos & Don'ts
Designing effective tool interfaces, error responses, and MCP server configuration.
✓ Do
- Write tool descriptions that include input formats, example queries, edge cases, and when to use this vs. similar tools
- Return structured error objects with
errorCategoryandisRetryable— not bare error strings - Return
isError: false, data: []for valid empty results — distinguish "not found" from "tool failed" - Store team MCP servers in
.mcp.jsonwith${ENV_VAR}credential expansion - Use
tool_choice: "any"when you need guaranteed tool execution - Keep per-tool tool descriptions distinct — the model uses them for selection; ambiguity causes wrong-tool calls
✗ Don't
- Merge two similar tools into one "mega-tool" as your first fix for wrong-tool selection — improve descriptions first
- Return bare error strings from MCP tools — the agent can't determine if it should retry
- Treat an empty result as an error —
data: []withisError: falseis a valid success response - Hard-code credentials in
.mcp.json— use environment variable expansion - Use
tool_choice: "auto"when tool execution is required — auto allows text-only responses - Deploy a pre-turn keyword classifier to route tool selection — use better descriptions instead
Prompting & Structured Output — Real-World Dos & Don'ts
Few-shot design, JSON schemas, validation loops, CI/CD prompting, and batch processing.
✓ Do
- Define explicit categorical criteria for what to report vs. skip — vague instructions like "be conservative" don't improve precision
- Make optional schema fields nullable (
field: null | string) — forces the model to output null rather than hallucinate - Use separate review passes (new Claude instance) to validate output — same session has confirmation bias
- Use few-shot examples with varied document structures when extraction quality is inconsistent
- Add calculated vs. stated total fields plus a discrepancy flag for semantic validation
- Use
-p/--printwith--output-format jsonfor all CI pipeline invocations
✗ Don't
- Instruct Claude "don't fabricate values" via prompt — make fields nullable in the JSON schema instead
- Make all schema fields required — this causes hallucination when data doesn't exist in the source
- Use the same session for generation and review — reviewer has context bias from generation
- Retry extraction failures indefinitely — absent data can't be retried into existence
- Use Batch API for pre-merge code review — developers are blocked waiting; that's a real-time workload
- Rely on a larger context window to handle context degradation — use scratchpad files to persist findings
Context Management & Reliability — Real-World Dos & Don'ts
Long conversations, escalation patterns, multi-agent error propagation, and human review.
✓ Do
- Extract transactional facts (amounts, dates, IDs) into a persistent "case facts" block outside summarized history
- Use scratchpad files to persist research findings across long Claude Code sessions
- Route to human review when confidence scores fall below a defined threshold — not based on sentiment
- Pass structured error context from subagents to coordinators — include what failed, why, and partial results
- Use
/compactto reduce context usage in long sessions nearing the token limit - Plan error propagation strategy before deployment — define what "structured handoff" means for your use case
✗ Don't
- Let conversation summarization silently drop precise transactional data — always preserve it in a structured block
- Use a larger model as the primary fix for context degradation in long sessions — use persistence strategies first
- Return a generic error string from a failed subagent — the coordinator needs structured context to recover
- Return empty success from a failed subagent — silently propagating failure is worse than surfacing the error
- Use sentiment analysis as the escalation trigger — explicit human request always overrides sentiment
- Assume 97% aggregate accuracy is sufficient for full automation — always validate per-type and per-field
Complete Exam Simulation
54 questions · All 6 scenarios · All 3 question types
CCA Foundations · Complete Exam Simulation
All 6 Scenarios.
All 3 Question Types.
54 questions across every scenario — Multiple-Choice, Multi-Select, and Scenario-Based. Filter by scenario or run the full deck.
Select scenarios to include (default: all)
54Questions
18Single-Answer
18Multi-Select
18Scenario-Based
Quick Reference Guide
All domains, scenarios, key tables at a glance
Exam at a Glance
720Minimum passing score (100–1000)
4 of 6Scenarios on your exam (random)
0 ptsPenalty for wrong answers — always guess
6 mo+Recommended hands-on experience
Content Domains & Task Statements
D1 · 27%
Agentic Architecture & Orchestration
- 1.1Agentic loop lifecycle — stop_reason control flow
- 1.2Multi-agent coordinator-subagent patterns
- 1.3Subagent spawning via Task tool; context passing
- 1.4Multi-step workflows; programmatic enforcement
- 1.5Agent SDK hooks — PostToolUse; interception
- 1.6Task decomposition — chaining vs dynamic
- 1.7Session state — --resume, fork_session
D2 · 18%
Tool Design & MCP Integration
- 2.1Tool descriptions = primary LLM selection mechanism
- 2.2Structured errors: errorCategory, isRetryable
- 2.3Tool distribution; tool_choice auto/any/forced
- 2.4MCP config — .mcp.json vs ~/.claude.json
- 2.5Built-in tools — Grep/Glob/Read/Write/Edit/Bash
D3 · 20%
Claude Code Config & Workflows
- 3.1CLAUDE.md hierarchy: user → project → directory
- 3.2Slash commands (.claude/commands/) & skills
- 3.3Path-specific rules (.claude/rules/) glob patterns
- 3.4Plan mode vs direct execution decision
- 3.5Iterative refinement — examples, test-driven
- 3.6CI/CD: -p flag, --output-format json
D4 · 20%
Prompt Engineering & Structured Output
- 4.1Explicit criteria over vague instructions
- 4.2Few-shot: 2–4 targeted ambiguous examples
- 4.3tool_use + JSON schema = reliable output
- 4.4Validation-retry loops; retry won't fix absent data
- 4.5Batch API: 50% savings, 24h window, no SLA
- 4.6Multi-pass review; independent instance
D5 · 15%
Context Management & Reliability
- 5.1Case facts block; trim verbose tool outputs
- 5.2Escalation: explicit requests honored immediately
- 5.3Structured error propagation up agent chain
- 5.4Scratchpad files; /compact; subagent delegation
- 5.5Stratified sampling; field-level confidence
- 5.6Claim-source mappings; annotate conflicts
6 Exam Scenarios (4 appear on your exam)
01
Customer Support Resolution Agent
Building an agent to handle returns, billing disputes, and account issues using MCP tools.
Primary: D1 · D2 · D5
02
Code Generation with Claude Code
Using Claude Code for development, refactoring, documentation, custom commands, and plan mode.
Primary: D3 · D5
03
Multi-Agent Research System
Coordinator delegates to specialized subagents for web search, document analysis, synthesis, reporting.
Primary: D1 · D2 · D5
04
Developer Productivity Tools
Agent helps explore codebases, understand legacy systems, generate boilerplate using built-in tools.
Primary: D2 · D3 · D1
05
Claude Code for CI/CD
Integrating Claude Code into automated pipelines for code review, test generation, PR feedback.
Primary: D3 · D4
06
Structured Data Extraction
Extracting structured information from unstructured documents with JSON schema validation and retry logic.
Primary: D4 · D5
5 Rules You Must Know
Over-EngineeringIf improving tool descriptions fixes the problem, don't build a routing classifier. The exam favors proportional solutions.
Prompt vs ProgrammaticWhen business-critical logic requires a guarantee, programmatic guardrails beat prompt instructions every time. Prompts are probabilistic.
Context IsolationSubagents do NOT inherit coordinator history. Always look for answers that explicitly pass context in the subagent's prompt.
Syntax vs Semantictool_use + JSON schema eliminates syntax errors only. Semantic errors (wrong values, math) require a separate validation pass.
Lost-in-the-MiddleModels miss content in the middle of long prompts. When an agent misses information, think about placement — move critical facts to the beginning.
Critical Tables
| tool_choice | Behavior | Use When |
|---|---|---|
"auto" | May return plain text — not guaranteed | General use; tool call not required |
"any" | Must call some tool | Guaranteed structured output needed |
{"type":"tool","name":"X"} | Must call that specific tool | Enforcing tool ordering / specific extraction |
| Error Category | isRetryable | Example |
|---|---|---|
transient | ✓ Yes | Timeout, service unavailable |
validation | ✗ No | Invalid input format |
business | ✗ No | Policy violation |
permission | ✗ No | Unauthorized access |
| Batch API | Real-Time API |
|---|---|
| 50% cost savings | Immediate response |
| Up to 24h processing (no SLA) | Guaranteed low latency |
| No multi-turn tool calling | Full tool calling support |
| ✓ Overnight reports, weekly audits | ✓ Pre-merge checks, interactive |
| ✗ Any blocking workflow | ✗ Cost-sensitive batch jobs |
Anti-Patterns Cheat Sheet
27 wrong approaches with correct alternatives — organized by domain
FAQ
40 questions · Searchable · Filterable by topic
No matching questions found.
Study Plan
2-week structured preparation · Check off tasks as you complete them
Overall Progress
0 / 0 complete