Claude Certified Architect – Foundations
Visual Exam Cheat Sheet

Built from the exam guide. This is optimized for pattern recognition, not prose reading. The exam is mostly testing whether you choose the most structured, explicit, scoped, deterministic answer in realistic scenarios.

Force > Ask If the workflow must be correct every time, enforce it with prerequisites, hooks, tool choice, or schemas.

Split > Big Prompt Large reviews and open-ended workflows should be decomposed into passes or subagents.

Tools > Prompts When tool selection is bad, first fix tool descriptions, names, boundaries, and access scope.

Structure > Free Text Prefer tool_use, JSON schema, explicit fields, structured errors, claim-source mappings, and manifests.

Limit > Expand Fewer tools, narrower roles, trimmed context, and scoped rules usually improve reliability.

Coordinator Owns Coverage In multi-agent systems, missing coverage usually means bad decomposition or poor context passing.

What the Exam Emphasizes

Domain 1

27%

Agentic Architecture & Orchestration

Loop on stop_reason
Coordinator-subagent patterns
Explicit context passing
Hooks, handoffs, prerequisites
Session resume vs fresh start

Domain 2

18%

Tool Design & MCP Integration

Tool descriptions drive selection
Structured MCP errors
Scoped tool sets
MCP project vs user config
Resources for catalogs

Domain 3

20%

Claude Code Configuration & Workflows

CLAUDE.md hierarchy
.claude/rules path scoping
Commands and skills
Plan mode vs direct execution
CI usage with print/json flags

Domain 4

20%

Prompt Engineering & Structured Output

Explicit criteria reduce false positives
Few-shot for ambiguity and consistency
JSON schema + tool_use
Validation-retry loops
Batch vs real-time

Domain 5

15%

Context Management & Reliability

Trim tool outputs
Persist structured facts
Escalation criteria
Crash recovery and scratchpads
Provenance and uncertainty handling

Meta

Exam style

How answers are framed

Single best answer
Usually a pragmatic first step
Rejects over-engineering
Rejects vague “improve prompt” fixes
Rewards explicit, narrow, reliable systems

Core Decision Tree: Few-shot vs More Examples vs Prompt Change vs System Change

1. Ask what kind of problem this is

Ambiguity? The model can do the task but makes inconsistent judgments.
Criteria problem? It does not know what to count, skip, or prioritize.
Guarantee problem? A step must always happen, output must be structured, or a business rule must be enforced.
Architecture problem? Coverage is missing, tool boundaries overlap, or workflow decomposition is wrong.

Use Few-shot

Ambiguous cases
Inconsistent formatting
Need examples of “report this, ignore that”
Need examples of correct handling across varied document formats

Good signal: “the model is inconsistent”

Change the Prompt

Need explicit criteria
Need clearer severity rules
Need narrower review scope
Need better escalation rules

Good signal: “too many false positives”

Change the System

Prerequisites, hooks, tool choice, schemas
Scoped tool access
Coordinator decomposition
Structured error payloads

Good signal: “must always”, “critical”, “production reliability”

Trap Map: If You See This, They Usually Want That

Situation / Signal	What is really wrong	Likely correct move	Common tempting wrong move	Why / exam philosophy
Tool selection is wrong	Tool descriptions are minimal or overlapping	Rewrite descriptions with inputs, outputs, examples, edges, boundaries	Add few-shot first, add classifier, merge tools immediately	Tools are the first fix for tool confusion
A specific order must always happen	Identity verification before refund, metadata extraction before enrichment	Use programmatic prerequisite, hook, or forced tool choice	Stronger prompt, more examples, confidence checks	If it must always happen, enforce it
Coverage is incomplete in multi-agent research	Visual arts covered, music/writing/film missing	Fix coordinator decomposition and task partitioning	Blame synthesis agent or search agent first	Coordinator owns coverage
Subagent output lacks context	Synthesis gets summaries without sources or dates	Pass structured findings with metadata explicitly	Assume context inheritance	Subagents do not inherit parent context automatically
Need multiple subagents at once	Parallel search/analysis tasks	Emit multiple Task calls in one coordinator response	Spawn sequentially across turns by default	Parallel spawning is preferred when independent
Model returns free text when schema is needed	CI comments, extraction, machine-readable results	Use tool_use and JSON schema, often with tool_choice any	Ask for JSON in natural language	Structure must be guaranteed
Output passes schema but content is still wrong	Totals do not add up, values in wrong fields	Add semantic validation and retry with explicit error feedback	Assume schema solved correctness	Schemas fix syntax, not semantics
Review has too many false positives	Developers stop trusting the tool	Write explicit report/skip criteria, disable noisy categories temporarily	Say “be conservative” or “only high confidence”	Specific criteria beats vague caution
Need consistent formatting and judgment	Same type of issue formatted differently each run	Add 2 to 4 targeted few-shot examples	Dump many generic examples	Few-shot works best when examples are sharp and targeted
Task is complex and architectural	Migration, restructuring, dozens of files	Use plan mode first, then execute	Jump directly into changes	Plan mode is for large uncertain work
Task is small and obvious	Single-file validation check	Use direct execution	Enter plan mode automatically	Do not over-plan simple tasks
Long session is degrading	Model references generic patterns instead of discovered facts	Use scratchpads, summaries, /compact, subagents	Keep everything in one long chat	Context drift is expected
Tool outputs are bloating context	40 fields returned, only 5 matter	Trim to relevant fields and persist structured facts	Keep full output in history	Context is a budget, not an archive
User explicitly wants a human	Customer asks for a human agent	Escalate immediately	Continue trying to solve unless they insist twice	Direct human request is an escalation trigger
Case is emotionally negative but solvable	Frustrated customer, straightforward issue	Acknowledge frustration and solve if possible	Escalate only because sentiment is negative	Sentiment is not complexity
Multiple customer matches are returned	Name maps to several accounts	Ask for another identifier	Pick the most likely match	No heuristic guessing on identity
Tool fails transiently	Timeout, service unavailable	Return structured error with retryability, recover locally if possible	Return empty success or generic failure	Errors must enable recovery
Tool hits business rule	Refund too large or policy exception	Block and route to escalation with explanation	Retry repeatedly	Business errors are not retry problems
Agent has too many tools	18 tools across roles	Reduce tool scope per agent, maybe give one cross-role verifier	Give even more tools	Too many tools degrades selection
Need simple fact verification from synthesis	Dates, names, simple stats often need checking	Give synthesis a scoped verify_fact tool	Give synthesis all search tools	Use narrow cross-role tools for common needs
Need shared team rules in Claude Code	Everyone cloning repo needs them	Project-scoped CLAUDE.md or .claude/commands/.claude/rules	Put them in ~/.claude	User-level config is not shared
Need path-specific conventions	Tests scattered across repo	Use .claude/rules with glob patterns	Use directory CLAUDE.md for cross-cutting patterns	Path-scoped rules beat directory location here
Need reusable command for team	Slash command should ship with repo	Put it in .claude/commands/	Put it only in user home	Project commands are version-controlled
Need isolated verbose workflow	Exploratory skill or brainstorming	Use skill with context: fork	Run it in main context	Fork preserves main context
Need CI usage	No interactive hangs, structured outputs	Use -p plus —output-format json and —json-schema	Run interactive defaults	CI needs non-interactive structured mode
Need overnight cost savings	Nightly report, weekly audit	Use Message Batches API	Use batch for blocking pre-merge checks	Batch is for latency-tolerant workloads
Need review of large PR	14 files, contradictory results	Split into per-file local passes plus integration pass	One giant pass, larger model only	Multi-pass beats single-pass
Need second opinion on generated code	Generator reviewed its own output	Use an independent review instance	Ask same session to self-review harder	Same-session self-review is weaker
Need to choose resume vs fresh start	Files changed since prior analysis	Resume only if context is mostly valid and tell it what changed, otherwise inject structured summary in new session	Blindly trust stale session outputs	Fresh summaries can beat stale history
Need provenance in synthesis	Multiple sources, conflicting stats, dates matter	Preserve claim-source mappings, dates, contested vs established sections	Collapse to one number without attribution	Provenance survives only if structured

Few-shot, More Examples, Prompt Rewrite: Where People Lose Points

Use Few-shot When…

The model already understands the task class.
It is inconsistent on edge cases.
You need stable output format.
You need to show “report vs skip” decisions.
You need varied examples for extraction formats.

Ambiguity

Consistency

Format

Do Not Reach for Few-shot When…

A step must be guaranteed.
A tool is poorly described.
The coordinator decomposed the task badly.
You need access control or business-rule enforcement.

Guarantee problem

Architecture problem

Provide More Examples When…

The issue is not one weird edge case, but a pattern.
You want coverage across multiple document or code patterns.
You need the model to generalize the desired judgment.

The guide repeatedly prefers 2 to 4 targeted examples, not a giant example dump.

Rewrite the Prompt When…

Criteria are vague.
Severity is inconsistent.
False positives are high.
Escalation boundaries are unclear.

Criteria problem

Precision problem

Exam Trap

”Add few-shot” often looks smart.
But the exam usually wants it only after simpler structural fixes.
If tool descriptions are bad, fix those first.
If compliance is required, enforce in code.

Fast Memory Rule

Examples teach judgment.
Prompts teach criteria.
Systems enforce guarantees.
Architecture fixes coverage.

Agentic Orchestration Patterns

Loop Control

Continue when stop_reason = tool_use
Stop when stop_reason = end_turn
Append tool results into history each iteration

Do not parse assistant text to decide when loop ends

Coordinator Role

Decide whether subagents are needed
Partition scope to avoid duplication
Aggregate and inspect for gaps
Redelegate targeted follow-up work

Subagent Context

No automatic inheritance
Pass complete findings explicitly
Separate content from metadata
Preserve attribution for downstream synthesis

Parallelization

Spawn multiple Task calls in one response for independent work
Use hub-and-spoke routing through coordinator
Do not let agents talk to each other directly

Handoffs

Human handoff should include customer details, root cause, key amounts, recommended action
Assume human may not see conversation history

Hooks and Enforcement

PostToolUse for normalization
Tool interception for business rules
Choose hooks when compliance must be deterministic

Error Handling and Recovery Patterns

Error payload should include

errorCategory
isRetryable
Human-readable explanation
Attempted action / query
Partial results
Potential alternatives

Transient

Timeouts
Service unavailable
Recover locally first
Propagate with structured context if unresolved

Retryable sometimes

Validation

Bad inputs
Ask for missing identifier
Fix request shape

Do not retry blindly

Permission

Missing access
Agent should explain limits
Coordinator may choose alternative path or escalation

Business / Policy

Refund exceeds threshold
Policy exception needed
Return non-retryable explanation and escalate

Not a transient failure

Anti-patterns

Generic “operation failed”
Return empty success for failures
Terminate whole workflow on one subagent failure
Hide partial results

Claude Code and MCP Quick Map

CLAUDE.md hierarchy

User: ~/.claude/CLAUDE.md
Project: root or .claude/CLAUDE.md
Directory-level files for local scope

User-level is not shared with team

.claude/rules

Use YAML frontmatter with paths
Great for tests across many directories
Reduces irrelevant context

Commands and skills

Shared slash commands: .claude/commands/
Skills: .claude/skills/
context: fork isolates verbose work
allowed-tools restricts capability

Built-in tools

Grep = content search
Glob = path matching
Read/Write = whole file operations
Edit = targeted change if anchor unique
Fallback: Read + Write when Edit is unreliable

MCP config

Project shared servers: .mcp.json
Personal servers: ~/.claude.json
Use env vars like $TOKEN
MCP resources expose catalogs and reduce exploratory calls

CI mode

-p or —print for non-interactive use
—output-format json
—json-schema
Independent review instance beats self-review

Context, Escalation, Provenance

Context trimming

Extract persistent facts: ids, dates, amounts, statuses
Keep facts outside summary blocks
Trim tool outputs to relevant fields

Lost in the middle

Put key findings near beginning
Use section headers
Prefer structured summaries over long middle sections

Escalate when…

User asks for human
Policy is ambiguous or missing
Cannot make meaningful progress

Not because sentiment is negative

Identity ambiguity

Multiple matches means ask for another identifier
No heuristic selection

Human review workflows

Use field-level confidence
Calibrate with labeled sets
Sample high-confidence cases too
Check accuracy by field and document type

Provenance

Preserve claim-source mappings
Include dates
Annotate conflicts instead of picking one value
Separate established vs contested findings

Question Phrases → Likely Answer Pattern

If the question sounds like this	Think this first
”must always”, “mandatory before”, “critical business logic”	Programmatic enforcement, prerequisite gate, hook
”similar tools”, “minimal descriptions”, “wrong tool chosen”	Improve tool descriptions and boundaries first
”ambiguous”, “inconsistent format”, “sometimes does X, sometimes Y”	Few-shot examples
”false positives”, “trust erosion”, “be more conservative”	Explicit criteria, maybe disable noisy categories
”large PR”, “14 files”, “contradictory findings”	Multi-pass review
”restructure”, “migration”, “many files”, “multiple valid approaches”	Plan mode
”returns text instead of structure”, “CI”, “extraction”	tool_use / JSON schema / tool_choice
”passes schema but wrong values”	Semantic validation and retry with feedback
”timeout”, “partial results”, “recovery”	Structured error propagation
”missing areas in report”	Coordinator decomposition too narrow
”subagent didn’t know prior findings”	Explicit context passing
”everyone on team should get this”	Project-scoped config, not user-scoped
”tests live all over repo”	Path-scoped rules with globs
”nightly / weekly / overnight”	Message Batches API
”blocking merge”	Synchronous API / non-batch
”same session reviewed its own code”	Independent review instance

Claude Certified Architect – FoundationsVisual Exam Cheat Sheet