CCA‑F: Exam Prep

Claude Certified Architect · Foundations

Study in English, with a Vietnamese safety net

Since your exam is in English, everything below is written in English — the same language you'll see on test day. Two hover mechanisms give you Vietnamese meaning without switching languages:

1) Dotted‑underline words — these are glossary terms. Hover over one to see its Vietnamese meaning in a small tooltip.
2) 🇻🇳 VI badge — appears at the end of most paragraphs, rows, and list items. Click it to insert a Vietnamese translation directly below the original text (click again to hide it). Technical keywords (subagent, MCP, CLAUDE.md, tool_choice, etc.) are kept in English inside the translation, since that's how they'll appear on the real exam.

Score weight per domain (based on the 77‑question Study Guide):

D1 · 27%Agentic Architecture
D2 · 18%Tool & MCP
D3 · 20%Claude Code
D4 · 20%Prompt & Structured Output
D5 · 15%Context & Reliability

Strategy: study D1 first (highest weight and most questions — 22), then D2+D3+D4 (similar weight each), then D5 last — it only has 3 questions in the bank but still counts for 15% of the real exam, so 3 focused principles are enough. VI

📅 Study Plan

Roughly 3–4 hours per phase. Use the three quiz files you already have for practice after reading each phase's theory.

Phase 1

Focus: D1 + D2 (45% of the exam)
  • Read all 21 Agentic Architecture & Orchestration principles below — the heaviest‑weighted domain. VI
  • Read all 15 Tool Design & MCP Integration principles. VI
  • Practice: open Quiz 1, complete it, and cross‑check the explanations in this lecture for every wrong answer. VI
  • Keep a personal "weak spots" list of missed questions to review again in Phase 3. VI

Phase 2

Focus: D3 + D4 (40% of the exam)
  • Read all 16 Claude Code Configuration & Workflows principles (flags, sessions, CLAUDE.md, exploration). VI
  • Read all 12 Prompt Engineering & Structured Output principles (schema design, few‑shot, batch vs. real‑time). VI
  • Practice: open Interactive Quiz, complete it, and revisit D1/D2 if your score is still low. VI
  • Review the Cheat‑sheet table to memorize the quick "decision rules." VI

Phase 3

Focus: D5 + full review + mock exam
  • Read all 3 Context Management & Reliability principles (Batch API, chunking context errors). VI
  • Quickly review all 5 domains using the Cheat‑sheet and the final Checklist. VI
  • Take the full mock exam: Practice Exam — time yourself like the real thing. VI
  • Only re‑fix the weak spots noted from Phases 1–2 — don't restart from scratch. VI
Domain 1 · 27% of the exam · 22 questions in the bank

Agentic Architecture & Orchestration

Multi-agent orchestration, coordinator–subagent patterns, task decomposition, parallel execution

🗺️ Big picture, from the source — this is a faithful redraw of Anthropic's own published multi-agent Research architecture, not something invented from the quiz questions. Component names (LeadResearcher, Subagents, Memory, CitationAgent) are Anthropic's actual names. Click any number to jump to that principle below.

"Our Research system uses a multi-agent architecture with an orchestrator-worker pattern, where a lead agent coordinates the process while delegating to specialized subagents that operate in parallel." — Anthropic Engineering, "How we built our multi-agent research system," Jun 2025
User query LeadResearcher — the orchestrator thinks & plans the approach first sizes subagent count to task complexity hands off with goals, not scripts 2 3 4 7 13 14 17 19 Memory plan persisted (200K token limit) 5 spawn ⇄ return findings 6 Subagents (3–5, parallel) own context & own tools interleaved thinking refines each query 1 8 15 16 External store full output saved only a reference returns 11 gap found → spawn again 10 loop exits → hand off CitationAgent matches every claim to its source document 9 18 20 Cited answer → User 12 21

Notice: only LeadResearcher talks to Subagents, Memory, and CitationAgent — subagents never call each other directly, and none of them spawn further children. That flat, hub‑and‑spoke shape is exactly what principles 8 and 19 describe.

Read it yourself: How we built our multi-agent research system ↗ · Building Effective Agents ↗

1

Agentic search over static context

VI

When the failure is a missing-context problem (e.g., a caller in an unchanged file isn't included in a static prompt), the fix is to turn the task into an agentic one where the model can read files and search the codebase via tools — not add chain-of-thought instructions or expand the prompt with static analysis.

2

Decomposing open-ended tasks

VI

Use Glob and Grep to map the codebase structure, prioritize high-impact and heavily-coupled areas, create a plan, and revise it as new dependencies are discovered — don't read every file exhaustively, split effort evenly by directory, or proceed arbitrarily.

3

Multi-phase workflows (analyze → propose → implement → review)

VI

This structure is most valuable for open-ended, judgment-heavy requests (e.g., "improve error handling"). Mechanical, well-defined tasks (e.g., a straightforward rename) gain little from the extra phases.

4

Three decomposition patterns: prompt chaining, routing, orchestrator-workers

VI

Prompt chaining fits a fixed, identical sequence of subtasks every time. Routing fits inputs that fall into distinct categories needing different handling. Orchestrator-workers fits subtasks that vary unpredictably per input and must be decided dynamically by a central LLM.

5

Restoring state after a crash

VI

Have each agent persist a structured export to a known location; on resume, the coordinator loads a manifest and injects only the relevant state into each subagent's prompt — don't rely on a full raw conversation log (too much context) or semantic vector search (lossy, may miss findings).

6

True parallel subagent execution

VI

The coordinator must emit multiple Task tool calls within a single assistant message — that's the only mechanism that makes the harness run subagents concurrently. Switching to a cheaper model, adding external async infrastructure, or simply instructing the model to "run in parallel" does not guarantee this.

7

"Task" must be in allowedTools

VI

If a coordinator with fully configured AgentDefinitions reasons about delegating but no subagent ever actually executes (with no errors logged), the most likely cause is that "Task" is missing from allowedTools — the model can talk about delegation but has no mechanism to invoke it.

8

Flat, non-recursive hierarchies

VI

To cut latency while keeping monitoring and debugging centralized, have the coordinator itself spawn parallel subagents and aggregate results — avoid nested/recursive agent hierarchies (subagents spawning their own subagents), which severely hurt observability.

9

Preserve attribution with structured data

VI

To avoid losing which claim came from which source during synthesis, require subagents to emit explicit structured claim-source mappings that the synthesis agent must preserve — not inline text-prefix conventions, post-hoc log analysis, or unreliable semantic-similarity reconstruction.

10

Closed feedback loops for gap detection

VI

When an analysis agent identifies a specific gap (e.g., "missing details on token refresh"), it should report that gap to the coordinator, which triggers targeted follow-up searches and re-runs analysis until coverage is sufficient — not just attach a confidence score and stop, or add an upfront planning agent.

11

Passing context between subagents

VI

Use reference identifiers pointing to a shared store rather than inlining full raw content into the prompt (bloats context, risks information loss) or relying on callbacks/automatic context inheritance (neither exists in this architecture).

12

Format-aware synthesis

VI

The synthesis agent should render each content type in its natural form — tables for financial comparisons, prose for news narratives — rather than flattening everything into one uniform format like bullet points.

13

Dynamic, LLM-judged query routing

VI

With a diverse and evolving query distribution, let the coordinator's LLM judgment decide dynamically how many and which subagents to invoke per query — static fast-paths, hand-coded pattern routing, and a classifier requiring periodic retraining all break down as patterns evolve.

14

Delegate with goals, not scripts

VI

Specify research goals and quality criteria (coverage breadth, source diversity, recency) rather than prescriptive step-by-step instructions — this lets a capable subagent adapt its own strategy instead of failing rigidly when a pre-specified approach doesn't work.

15

Purpose-specific tools over one generic tool

VI

When a single free-text tool produces inconsistent output formats across different task types, split it into narrowly-scoped tools with explicit input/output contracts (e.g., extract_data_points, summarize_content, verify_claim_against_source) rather than adding an enum parameter, better descriptions, or pre-classification.

16

No automatic context sharing between subagent calls

VI

Each subagent invocation is a stateless API call with its own isolated context — the coordinator must explicitly inject the prior agents' outputs into the next subagent's prompt, or that subagent will report having no information at all.

17

Don't spawn a subagent when the coordinator already has the context

VI

If the coordinator already holds all the needed findings in its own context (e.g., from orchestrating prior research), handle a simple follow-up (like summarization) directly rather than spawning a subagent and re-transferring tens of thousands of tokens — that's pure latency overhead.

18

A structured source index for the report generator

VI

Pass the synthesis draft together with a structured source index mapping key claims to their source URLs and excerpts — this is the best balance of completeness and efficiency, better than passing all raw content, name-only attribution, or post-hoc citation matching.

19

The coordinator is always the hub

VI

In an orchestrator-worker pattern, subagents never call each other directly, and there's no event bus or automatic sibling access — all information flows through the coordinator, which explicitly forwards relevant output into the next subagent's prompt.

20

Include timestamps/metadata in structured output

VI

If two sources report different numbers over time (e.g., 2022 vs. 2024) and the synthesis agent wrongly flags them as "contradictory," the fix is requiring every data point to carry its own publication or collection date — that lets synthesis reason about trends instead of conflicts.

21

Handling uncertainty through report structure

VI

Preserve the original source characterization and methodological context, and structure the report to separate well-established findings from contested ones — don't average conflicting estimates that use different methodologies, silently filter out uncertain data, or require a rigid two-source minimum.

Domain 2 · 18% of the exam · 20 questions in the bank

Tool Design & MCP Integration

Tool design, built-in tools (Grep/Glob/Bash), MCP servers, tools & resources

🗺️ Big picture, from the source — grounded in Anthropic’s official Model Context Protocol architecture (client/server tool calls) plus the standard tool-result and escalation patterns from the CCA-F question bank. Click any number to jump to that principle below.

"The architecture is straightforward: developers can either expose their data through MCP servers or build AI applications (MCP clients) that connect to these servers." — Anthropic, "Introducing the Model Context Protocol," Nov 2024
MCP tool-call loop Claude (agent) 13 11 MCP Client MCP Server(s) Jira / Docs / … 1 2 3 4 Tool result isError+category 12 reasons over tool_result, turn by turn Conversation reliability Stateless API resend full messages[] 11 Stale session resume fresh + inject summary 5 Long multi-issue chat summarize resolved, keep active 14 40+ field result prune to relevant fields 15 Escalation & degradation Escalate? human ask / policy / stuck 6 Structured handoff ID+cause+amount+action 7 8 Tool fails, info known explain + ack + offer choice 9 Customer wants human, issue simple → offer fix 10

Read it yourself: Introducing the Model Context Protocol ↗ · Writing effective tools for agents ↗

1

Choosing the right built-in tool

VI

Grep searches file contents for a pattern (e.g., every call site of eval() or every import of a package) — this is the right choice whenever the task is about content, not filenames. Glob matches file names/paths, Read opens a known file, and Bash executes commands.

2

Use an existing MCP server for standard services

VI

For data from a common third-party service (like Jira), integrate an existing MCP server, which provides discoverable, typed tools with managed authentication — building a custom server, exporting to markdown, or using ad-hoc curl calls are all worse fits when a standard integration already exists.

3

MCP Resources reduce exploratory tool-call round trips

VI

When an agent makes 8-10 sequential tool calls because it has no visibility into what each server contains, expose each server's content catalog as MCP resources (issue summaries, doc hierarchies, schemas) so the agent can browse before acting — don't consolidate servers into a monolith or add keyword-based routing.

4

Fewer tools improves tool selection accuracy

VI

Tool selection accuracy degrades as the number of available (especially irrelevant) tools grows. Scope each specialized subagent to only 4-5 role-relevant tools rather than exposing all tools to every agent.

5

Stale tool results in a resumed session

VI

When resuming an old session whose tool results are now outdated (e.g., an order status that has since changed), start a fresh session, inject a structured summary of the prior interaction, and make fresh tool calls before responding — don't strip tool_results from mid-transcript (creates inconsistency) or just instruct the model to "prefer the latest result" (unreliable).

6

Escalation logic based on natural-language judgment

VI

The most reliable escalation criteria are: the customer explicitly requests a human, the issue requires a policy exception, or the agent cannot make meaningful progress — this outperforms a hard retry-count threshold, sentiment analysis, or a rigid rules engine.

7

A structured handoff for human agents

VI

When escalating, pass a structured summary — customer ID, root cause, amount, and recommended action — not the raw transcript or just the customer's original complaint, so the human can act immediately without re-investigating.

8

Compliance-critical rules require a deterministic hook, not a prompt

VI

If a rule "cannot be left to model discretion" (e.g., refunds over $500 must always escalate), enforce it with a hook that intercepts the tool call and blocks it — even a strongly worded system prompt still has a nonzero failure rate and is not compliance-grade.

9

Graceful degradation when a tool fails

VI

When a backend action fails (e.g., a refund times out) but other information is already known, explain what's understood, acknowledge the failure honestly, and offer the customer a choice (escalate or retry) — don't promise an outcome that hasn't happened, and don't escalate immediately while ignoring the value already delivered.

10

Respect the customer's stated preference

VI

If a frustrated customer explicitly asks for a human but the issue is actually simple and resolvable in one tool call, acknowledge the frustration, state that it can be resolved now, and let the customer choose — don't unilaterally act against their stated preference, and don't escalate unnecessarily for a trivial fix.

11

The API is stateless

VI

If the agent "forgets" information mid-flow, the cause is almost always that the full conversation history wasn't included in the latest request — not a missing "remember this" instruction, and not some default two-turn memory limit (no such limit exists).

12

The standard MCP error pattern

VI

Return the error message in the tool result's content field with isError set to true, ideally enriched with a structured errorCategory (transient/validation/permission) and an isRetryable flag — not a thrown exception, not a silent empty result, and not an ad-hoc "status" field.

13

The agentic loop reasons turn by turn

VI

The model decides its next action by reasoning over the tool_result just appended to the conversation — there is no implicit orchestration layer routing by field value, no hard-coded decision tree, and no pre-planned sequence of tool calls fixed at the start.

14

Managing context in long, multi-issue conversations

VI

Summarize resolved topics into a narrative description while keeping full message history only for the currently active issue — a plain sliding window risks silently dropping an earlier issue the customer later asks about again.

15

Pruning bulky tool output

VI

When a tool response includes 40+ fields, extract only the fields relevant to the current task and drop the rest — this is more reliable than paraphrasing into prose (loses precision on exact values) or standing up a vector database (overkill for a simple pruning problem).

Domain 3 · 20% of the exam · 18 questions in the bank

Claude Code Configuration & Workflows

Claude Code flags, CLAUDE.md, sessions, permissions, developer workflows

🗺️ Big picture, from the source — grounded in Anthropic’s official Claude Code best-practices guide (the Explore → Plan → Implement → Commit loop, CLAUDE.md, hooks vs. advisory instructions, subagents). Click any number to jump to that principle below.

"Unlike CLAUDE.md instructions which are advisory, hooks are deterministic and guarantee the action happens." — Anthropic, "Best practices for Claude Code"
Core dev loop CLAUDE.md standards+examples 2 Explore Grep/Glob/Read 15 8 5 Plan Mode (open-ended only) 16 Implement Edit/Write 14 Commit Session & context management --continue vs --resume <name> 3 fork_session parallel branches 9 Interrupted, told what changed 6 10 Context degrades → summarize → new subagent 7 Scratchpad file durable memory 11 Subagent deep-dive, main keeps overview 12 Headless & debugging style --max-turns --max-budget-usd 1 Adaptive debugging step from findings 13 Vague tool description → built-in used instead 4

Read it yourself: Best practices for Claude Code ↗

1

Cap iterations and spend with native Claude Code flags

VI

--max-turns caps the number of agentic iterations and --max-budget-usd caps the dollar spend per invocation, both enforced natively by Claude Code in headless (claude -p) mode — a CI job timeout or a passive dashboard only monitors from the outside and doesn't enforce either limit directly.

2

CLAUDE.md shapes output quality at the source

VI

To reduce low-value generated output (e.g., trivial tests), document team standards, fixture conventions, and good-vs-bad examples in CLAUDE.md — fixing the root cause at generation time beats filtering bad output after the fact.

3

--resume <name> vs. --continue

VI

--resume session-name loads that exact named session with all its accumulated context. --continue only resumes the most recent conversation, which may not be the one you want if you've worked on other things since.

4

Tool descriptions are the primary lever for tool selection

VI

If an agent keeps using a built-in tool (like Grep or sed) instead of a specialized MCP tool, the root cause is usually a vague MCP tool description — write a detailed description of capabilities, outputs, and when to use it, rather than removing built-in tools or adding brittle routing rules.

5

Functions re-exported under different names

VI

Before grepping for every caller of a function that's re-exported through wrapper modules under different names, first read the library and wrappers to enumerate every exposed alias — grepping only the original name will miss aliased callers.

6

Resuming an interrupted subagent with a small update

VI

When an exploration session is interrupted and a small change occurred in the meantime (e.g., a renamed function), resume from the saved transcript (keeps the accumulated context) and explicitly inform the agent of that specific change — don't restart from scratch, and don't resume silently while ignoring the change.

7

Context degradation in long sessions

VI

When responses become generic ("typical patterns") instead of referencing the specific classes/functions discovered earlier, summarize the key findings, then spawn a subagent for the next task with that summary as its starting context — don't just /clear (loses everything) or keep going in the degraded context.

8

Building understanding of a large module

VI

Identify the base class/interface first, read it to understand the shared abstraction, then trace the specific implementations relevant to the task — more effective than reading every file sequentially, prioritizing by file size, or only grepping keywords.

9

fork_session for independent parallel exploration

VI

To compare two approaches (e.g., two testing strategies) starting from the same analysis baseline, use fork_session to create separate branches — this avoids exploring sequentially in one thread (cross-contamination) or manually recreating context in fresh sessions.

10

Files changed during a session gap

VI

Resume the session (keeps efficiency) and explicitly tell the agent which specific files changed for targeted re-reading (keeps accuracy) — don't re-read everything, don't start fresh, and don't resume silently.

11

A scratchpad file for durable "memory"

VI

When an agent starts giving inconsistent answers after 30+ minutes of exploration, have it maintain a scratchpad file recording key findings and reference it going forward — more stable than switching to a bigger model, clearing context on a timer, or pre-summarizing every source file upfront.

12

Subagents for deep dives, main agent keeps the overview

VI

When a codebase is too large to fit in one context window (e.g., 45 files), delegate well-scoped questions to subagents with fresh context while the main agent retains the high-level architectural understanding — this is the pattern for scaling exploration beyond a single context window.

13

Debugging is adaptive, not pre-planned

VI

Let the agent dynamically generate its next investigation step based on what it just discovered — planning the entire path before any exploration (planning blind) or fanning out parallel workers across every layer when you don't yet know which layer is involved both waste effort.

14

When Edit fails on a non-unique old_string

VI

In a file with repetitive patterns (similar docstrings, variable names), the reliable fallback is: Read the whole file, make the change in memory, then Write it back — not a longer match string (still fragile), not replace_all (corrupts other matches), and not appending to the end (wrong location).

15

Exploring an unfamiliar, large codebase

VI

Use Grep to find concrete entry points (login, middleware) and trace outward following real import/function-call edges incrementally — reading every file containing broad keywords ("auth", "token") across 800+ files drowns the context in noise.

16

A localized bug doesn't need Plan Mode

VI

When a stack trace already points to a specific area, go straight to direct execution — read the trace, read the relevant code, fix the root cause once found. Plan Mode is reserved for genuinely open-ended or architecturally complex problems, not an already-localized bug.

Domain 4 · 20% of the exam · 14 questions in the bank

Prompt Engineering & Structured Output

Prompt engineering, few-shot examples, structured output, confidence & severity metadata

🗺️ Big picture, from the source — grounded in Anthropic’s official structured-outputs and output-consistency documentation (schema-constrained decoding, few-shot examples, retries). Click any number to jump to that principle below.

"Structured outputs constrain Claude’s responses to follow a specific schema, ensuring valid, parseable output for downstream processing." — Anthropic, "Structured outputs" documentation
Two-stage extraction pipeline Find stage (coverage, flag all) 1 Filter stage (apply threshold) 1 Segment-level accuracy check 4 Field confidence + calibrated threshold 12 Schema design for messy reality Nullable field + 'return null' instr. 7 Versioned values → multiple+source+date 5 Calculated vs stated → flag discrepancies 9 Evolving categories → enum 'other'+detail 11 tool_choice forces order, that turn only 10 Batch (50% cheaper, ≤24h) vs real-time 2 Fixing extraction errors Inconsistent format → few-shot canonical examples 3 8 Missing info truly absent → retry can't invent it 6

Read it yourself: Structured outputs ↗ · Increase output consistency ↗

1

Separate "find everything" from "filter it"

VI

An instruction like "only report high-confidence issues" is followed literally and kills recall. Instead, split the process into a finding stage where the goal is coverage — flag every potential issue with confidence and severity metadata — and a separate downstream stage that applies the threshold.

2

Batch API vs. the real-time Messages API

VI

The Batch API is 50% cheaper but asynchronous (up to a 24-hour window) — appropriate only when that latency remains acceptable for your workflow. Time-sensitive work with a tight SLA (e.g., alerts within 30 minutes) must use the real-time Messages API instead.

3

Few-shot examples fix extraction consistency

VI

When compound phrases are split inconsistently, array lengths vary wildly, or output formats differ each time, add few-shot examples demonstrating the exact canonical format you want — more effective than hard count caps, a bigger model, or setting temperature to 0.

4

Check accuracy by segment before automating

VI

Aggregate accuracy (e.g., 97% overall) can hide a document type or field where accuracy is much lower. Always analyze accuracy by document type and field before automating decisions based on a confidence threshold.

5

Schema design for versioned or conflicting values

VI

For fields that can be amended over time (e.g., a contract clause changed by a later amendment), capture multiple values each with a source location and effective date — don't force one value, hard-code "the latest always wins," or destructively strip superseded sections.

6

Retry-with-error-feedback cannot invent missing information

VI

Retries reliably fix format and structural mistakes the model could have gotten right. They cannot fix a case where the needed information genuinely doesn't exist in the input (e.g., "et al." because the full author list is only in an external document).

7

Explicitly instruct "return null, don't guess"

VI

Even nullable fields can still get a plausible-but-wrong value hallucinated by the model. Add an explicit instruction to return null when information isn't stated — don't make the field required (that forces the model to invent a value).

8

Few-shot examples across varied real-world formats

VI

When the model misses information that's genuinely present but presented in an unfamiliar structure (inline citations vs. bibliography, methodology embedded in an intro), few-shot examples spanning that format variety raise recall — regex post-processing and retries don't teach the model to recognize new structures.

9

Surface discrepancies instead of silently fixing them

VI

Add a calculated field (e.g., calculated_total, summed from line items) alongside the stated field (stated_total), and flag records where they differ for human review — don't have the model or a second pass silently reconcile financial data.

10

Force tool-call order with tool_choice

VI

When a pipeline tool is sometimes called before a prerequisite tool it depends on, force the correct one first with tool_choice: {"type": "tool", "name": "..."} for that turn, then switch back to "auto" for subsequent turns — don't rely on the order tools are listed in (no such priority exists).

11

An evolving enum needs an "other" escape hatch

VI

When new categorical values keep appearing (e.g., new property types), add an "other" enum value plus a separate detail string field — this keeps strict validation for common cases while avoiding endless enum maintenance or the validation loss of switching to free text.

12

Field-level confidence to prioritize limited review capacity

VI

When reviewers can only check a fraction of extractions, have the model output field-level confidence scores and calibrate the review threshold using a labeled validation set — this concentrates reviewer attention on errors far more effectively than random sampling or narrow heuristics like "only empty fields."

Domain 5 · 15% of the exam · 3 questions in the bank (quick to learn, high payoff)

Context Management & Reliability

Context management, batch/async APIs, retries, reliability

🗺️ Big picture, from the source — grounded in Anthropic’s official Batch API and context-window documentation. Only 3 principles here, but they cover 15% of the real exam. Click any number to jump to that principle below.

"You can access batch results when all messages have completed or after 24 hours, whichever comes first. Batches expire if processing does not complete within 24 hours." — Anthropic, "Batch processing" documentation
Batch reliability decision Is 24h delay still actionable? 1 Safe cadence: window+SLA+margin 2 context_length_exceeded → chunk & resubmit failed only 3

Read it yourself: Batch processing ↗ · Context windows ↗

1

The deciding factor for using the Batch API

VI

The Batch API saves 50% but can take up to 24 hours. The core question is always whether results arriving up to 24 hours later remain actionable for your workflow — not result ordering (already correlated via custom_id) or whether a request needs multi-turn refinement.

2

Calculating a safe batching cadence

VI

Worst-case wait-to-be-batched plus the batch processing SLA (up to 24 hours) must fit comfortably within your overall SLA, with a safety margin for reliability. Example: batching every 4 hours plus a 24-hour batch window = a 28-hour worst case, leaving a 2-hour cushion under a 30-hour SLA.

3

context_length_exceeded errors: fix only the failed subset

VI

When a small percentage of documents in a large batch fail due to exceeding the context length, the cost-effective fix is to chunk and resubmit only those failed documents, then merge the partial results — not reprocessing the entire batch, and not increasing max_tokens (which controls output length, not input length).

🧭 Cheat‑sheet — quick decision rules

Quick lookup before you walk into the exam room. Skim this table 5 minutes before your mock exam.

SituationChoose
Search content/pattern inside filesGrep VI
Search by file name/pathGlob VI
Two independent subagents need to run in parallelEmit both Task tool calls in the SAME message VI
Subtasks vary per input, unpredictableOrchestrator-workers VI
Same fixed steps every timePrompt chaining VI
Inputs fall into distinct categories, handled differentlyRouting VI
Coordinator can't spawn a subagent, no errorsCheck whether "Task" is in allowedTools VI
A mandatory compliance rule (must never be violated)A deterministic hook blocking the tool call — NOT a prompt VI
When should you escalate to a human?Customer asks / needs a policy exception / agent is stuck VI
An MCP tool errorcontent + isError:true + errorCategory + isRetryable VI
The model "forgets" information mid-conversationCheck whether the full messages array is being sent (API is stateless) VI
Reduce low-quality output from the startWrite criteria/examples into CLAUDE.md VI
Cap cost/iterations per headless run--max-turns / --max-budget-usd VI
Agent picks a built-in tool over a specialized MCP toolWrite a more detailed MCP tool description VI
Edit fails because old_string isn't uniqueRead the whole file → edit in memory → Write it back VI
Context degrades after a long session (vague answers)Summarize, then hand off to a fresh subagent VI
You want to stop missing bugs ("only report high-confidence")Split the coverage stage from the threshold stage VI
Urgent work needing an alert within minutesReal-time Messages API, NOT Batch VI
Non-urgent, high-volume, cost-sensitive workBatch API (50% cheaper, up to 24h) VI
A field may have no information in the sourceInstruct: return null instead of guessing (don't require it) VI
Can retries fix "missing information not in the input"?No — only few-shot examples or better source data can help VI
context_length_exceeded on a few % of documents in a large batchChunk and resubmit ONLY the failed documents VI

Tip for scenario-based questions: there is almost always one answer that "sounds reasonable but is really a surface-level patch/workaround" and one answer that "fixes the root cause following Anthropic's best practice." Prefer the answer that (1) puts the decision at the right layer of responsibility (deterministic code vs. model reasoning), (2) doesn't waste context or cost unnecessarily, and (3) doesn't break the stateless/context-isolation principle between agents. VI

💡 Tip & Tricks Ôn Thi CCAF

Người tổng hợp: TRUNGHM6 — mẹo làm bài, quy tắc loại trừ đáp án, và quy trình đăng ký/đi thi thực tế.

📚 Tài liệu ôn tập

  • Lý thuyết + giới thiệu bài thi: CCA_Foundations_Study_Guide.pdf
  • Tài liệu submit chứng chỉ FPT: "How to upload cert evidence to claim your fee v1.0.2.pdf"

🔗 Các trang thi thử

📝 Một số thuật ngữ hay sử dụng

TừNghĩa
DisputeTranh chấp, bác bỏ.
Accumulate / AccumulatedTích lũy, dồn lại.
Consolidate / ConsolidatedTập lại, gộp lại (merge).
AmendmentsChỉnh sửa, điều chỉnh, bổ sung.
RevealsTiết lộ, làm lộ ra.
PropagateTruyền, lan truyền.
LeverageTận dụng.
ContradictoryMâu thuẫn.
Hate speechNgôn từ kích động thù ghét.

🛠️ Mẹo khi trả lời câu hỏi về tools call

  • Tool overlap: Consolidate / merge các tool lại với nhau.
  • Quá nhiều tool: Giảm số lượng tool, dùng tool search.
  • Tool quá generic: Tách thành các purpose-specific tools.
  • Tool nhiều atomic: Gộp thành pipeline.
  • Tool select sai: Cải thiện mô tả (description).
  • Thiết kế tool: Nên ít tham số nhất, tránh quá generic, tạo quá nhiều thì cần merge với nhau.
  • Logic quan trọng: Business logic quan trọng phải được force ngay trong tool / backend services (không phụ thuộc hoàn toàn vào LLM).

💬 Mẹo khi trả lời câu hỏi prompt/context

  • Prompt bị quá tải: Chia để trị (Divide and Conquer) — nếu bài cho context bị giảm chất lượng, cần state hoặc summary key‑finding mỗi step.
  • Tập trung cải thiện: Đơn giản hoá, dùng few‑shot, v.v.
  • Nếu áp dụng cùng instruction cho nhiều request: Sử dụng Prompt Caching.
  • Xử lý Attribute (thuộc tính):
    • Attribute nằm trong prose (văn bản tự do) → dễ bị mất / bỏ sót.
    • Attribute nằm trong structured data → giữ được dữ liệu tốt hơn.
  • Xử lý tác vụ nhỏ / sub-tasks:
    • Tác vụ nhỏ (như execution) → nên dùng few‑shot.
    • Trong Claude CLI, nhớ tham số -p, --append-system-prompt — xác định rõ mục tiêu làm gì.

⚠️ Mẹo trả lời câu hỏi về xử lý lỗi

  • 503, Timeout, Network error: Thực hiện Retry + Backoff.
  • Invalid input: Return ngay + Validate / Debug.
  • Auth error: Không Retry.
  • Permission error: Return error.
  • Thường có 3 loại lỗi: lỗi system (503, 403, v.v.) — nên retry tự động; lỗi business như không có quyền → không retry, trả về ngay; lỗi validation → return lỗi validation, để orchestration có thể sửa và retry.
  • Các sub-agent luôn phải trả kết quả có cấu trúc (structured results — bao gồm cả source, link, v.v.) khi trả về cho orchestration.

🔒 Mẹo trả lời câu hỏi security và escalate

  • Nếu đề cho không được quyết định bởi model → nghĩ đến Hook (PreToolUse, PostToolUse).
  • Bảo mật, chi phí, giới hạn: Xử lý ở backend logic / API code của tool / orchestrator layer.
  • Cần chính xác 100%: Sử dụng code, rule-based, hook, gateway.

🚫 Mẹo / Quy tắc loại trừ đáp án khi làm bài

  • Hệ thống enforced mechanism:
    • Nếu bài yêu cầu enforced mechanism → dùng Settings và Hook.
  • Bổ sung context: Prompt thêm mã / code khi nói về context (few-shot).
  • Lỗi JSON: Thêm strict schema khi gặp lỗi JSON, thêm few-shot 2-4 ví dụ.
  • Escalate: Escalation nên bao gồm thông tin đang xử lý (customer ID, lỗi gì, v.v.) — không nên hỏi lại để làm rõ (clarify).
  • Sửa tên hàm: Nếu không có tên hàm cụ thể, chỉ cần replace all là được.
  • Không bao giờ chọn đáp án: đổi tier model, chỉnh temperature, tạo async API requests, parallel worker, fine-tuning, v.v.
  • Không cần ưu tiên phương án phức tạp về kiến trúc — đi theo luồng xử lý: Tình huống → có xử lý được bằng prompt không → nếu không → xử lý bằng hook → nếu hook không xử lý được → sub-agent → trả về kết quả. Luôn ưu tiên đáp án đơn giản, hiệu quả.
  • Khi yêu cầu về luồng xử lý lỗi: Grep (tìm string), Glob (tìm file) là hiệu quả nhất.

⚡ Flow ôn thi nhanh lẹ

  1. Đọc lý thuyết qua ở Study Guide.
  2. Vào Link 2 làm tầm 50 câu, hoặc nếu có thời gian thì đảo qua hết các câu ở đó.
  3. Vào làm Link 1 vài lần để thi thử giống thật — tầm 2 lần, nếu trên 800 điểm thì đi thi.
  4. Đi thi (kể cả giám khảo có ping bạn cũng đừng hoảng).

🎓 Cách đăng ký từng bước và khi thi

  1. Vào trang: anthropic-partners.skilljar.com/claude-certified-architect-foundations-certification
  2. Tạo account, đăng ký như bình thường, dùng email FPT — nhớ điền đúng tên và họ như trên giấy tờ tuỳ thân (hộ chiếu hoặc bằng lái xe) vì sẽ dùng để đối chiếu khi đi thi.
  3. Sau khi đăng ký xong thì cần đăng ký thi.
  4. Từ Home → chọn Course trên Top Nav → chọn CCA‑F (FOUNDATION).
  5. Click Register for the exam — $125.00 → tiến hành thanh toán.
  6. Thanh toán xong sẽ có 3 email gửi về: 1 mail bill, 1 mail account, 1 mail password — vì không thi trên nền tảng của Anthropic mà thi qua bên thứ 3 là Pearson.
  7. Trong email sẽ có link đăng nhập vào Pearson để đặt lịch thi, thời gian thi.
  8. Khi đặt lịch có thể chọn offline hoặc online, và chỉ được đổi lịch trước 48h thi.
  9. Trước ngày thi 3 ngày sẽ có email gửi thông tin link check‑in và quy chế thi.
  10. Từ email, chọn link test-system để tải phần mềm chạy chẩn đoán trước.
  11. Trước giờ thi 30 phút, click vào link check‑in trong email để vào luồng thi (chỉ mở trước giờ thi 30 phút) — sẽ có mã QR để dùng điện thoại quét, chụp ảnh không gian thi.
  12. Khi thi cần làm thủ tục: chụp ảnh khu vực thi (trên, dưới, trái, phải, v.v.), submit bằng điện thoại, và có người review.
  13. Submit xong tuyệt đối không dùng điện thoại nữa.
  14. Trong lúc thi có ô chat — giám khảo (người thật, không phải AI) thỉnh thoảng nhắn về sự cố như rớt mạng, đừng hoảng; cứ chat lại bình thường, hoặc cần trợ giúp thì chat hỏi.

✅ Pre-Exam Checklist

📁 Files You Already Have for Practice

docs/CCA_Foundations_Study_Guide.pdf — the original 77-question bank with full explanations by domain (the source of this lecture). VI
quizzes/quiz-1.html — practice quiz, use in Phase 1. VI
quizzes/interactive-quiz.html — interactive practice quiz, use in Phase 2. VI
quizzes/practice-exam.html — full mock exam, use in Phase 3 to simulate the real test. VI

🎯 Practice Quizzes

Finished reading the principles above? Pick a quiz below and test yourself — each one draws from the same question bank, just in a different format.

Quiz 1

77 questions

One question at a time, with an instant right/wrong check and a running score as you go. Best for your first pass through the question bank. VI

Start Quiz 1 →

Interactive Quiz

147 questions

A larger, expanded pool with extra scenario variations. Pick a custom question range to drill, and review every wrong answer at the end. VI

Start Interactive Quiz →

Practice Exam

77 questions

The full mock exam: every question on one scrollable page, with domain filters and a final score broken down by domain — the closest simulation of test day. VI

Start Practice Exam →

Suggested order: start with Quiz 1 to get comfortable with the format, use the Interactive Quiz for extra reps on your weak spots, then finish with a timed run of the Practice Exam to simulate the real thing. VI