The 5 Judgment Patterns the CCA Exam Actually Tests

Summary:

1. The CCA exam grades pattern recognition under a clock, not API trivia. Every question is a broken system and four fixes.
2. There are 5 reusable scenario archetypes: scale-failure, wrong-tool-routing, silent-failure, cross-machine-portability, trust-boundary.
3. Each pattern has fixed stem cues and a one-line architectural fix. Name the pattern, the wrong answers fall away.
4. Bonus deliverable: a one-page scan-and-match cheatsheet you pin next to the screen on exam day.

The Claude Certified Architect exam does not reward you for knowing what output_config.format does. It rewards you for reading a two-paragraph scenario about a customer’s broken chatbot and knowing, in ten seconds, which of five failure shapes you are looking at. Recognition is a lookup, not a memorization. That single reframe is the difference between a 985/1000 and the architect who tweeted that he failed by three or four questions and has to wait to sit it again.

What is the CCA exam actually testing?

It is testing whether you can recognize a scenario archetype before you evaluate the answers. The Claude Certified Architect Foundations exam is 60 multiple-choice scenario questions, 120 minutes, closed-book, video-proctored, 720 out of 1000 to pass, $99 per attempt. The five domains are weighted 27% (Agentic Architecture and Orchestration), 18% (Tool Design and MCP Integration), 20% (Claude Code Configuration and Workflows), 20% (Prompt Engineering and Structured Output), and 15% (Context Management and Reliability).

Here is the part the 460-page bricks miss. The domains are the syllabus. They are not how the questions are built. The questions are built from five reusable judgment patterns that cut across all five domains. A silent-failure question can appear in Domain 1 or Domain 5. A trust-boundary question shows up in Domain 2 and Domain 4. Study the domains and you know the territory. Study the patterns and you know the questions.

The community study guide at github.com/paullarionov/claude-certified-architect (2k stars, 447 forks) says the same thing in one line:

“Use the Practical Scenarios section to rehearse key patterns (tool design, MCP integration, structured output, context management, and reliability).”

Its repo is structured around scenario rehearsal, not chapter summaries:

claude-certified-architect/
├── guide_en.MD             # English study guide (also: ar, es, ja, ko, ru, zh)
├── practical_test_en.html  # Practical scenario tests (also: ja, ko, ru, zh)
├── pdf/                     # Generated guide PDFs
└── utils/                   # HTML builder + per-language files

Patterns, not chapters. The repo is built around scenario rehearsal because the exam is.

What are the 5 judgment patterns?

There are five, and each one has a fixed set of stem cues and a fixed one-line fix. This is the entire mental model. Memorize the cues, not the answers.

Pattern	Stem cues	One-line fix
1. Scale-Failure	at scale / p99 / latency / rate limits	Batch + cache + fallback
2. Wrong-Tool-Routing	right task / wrong tool / wrong call	Tighten descriptions, scope subagent tools
3. Silent-Failure	no alerts / looks fine / wrong answer	Assertions + golden set + judge
4. Cross-Machine-Portability	works here / breaks there / environment drift	Scope the config
5. Trust-Boundary	untrusted input / over-permissive / blast radius risk	Blast radius + least-privilege

Now the depth on each, because the cue is the trigger and the fix is the reflex.

Pattern 1: Scale-failure. The system worked in development and is breaking under production traffic. The stem mentions a cost spike, a p99 latency miss, or a rate limit. The architectural fix is always three moves in order: route asynchronous work to the Batch API (50% off both input and output tokens, not 30% — the wrong number is a deliberate distractor), cache the stable system prompt (90% off cache reads), and wrap the remaining synchronous calls in a fallback loop with exponential backoff. The trap answer is “switch to a cheaper model.” That is a knob-turn, not an architecture change.

Pattern 2: Wrong-tool-routing. The agent picks the wrong tool. It fires the ticket-filing tool when the user asked a research question. The fix is two moves: tighten the tool descriptions so the routing intent is unambiguous, and scope each subagent’s tool list so the wrong tool is not even reachable. The trap answer is “improve the system prompt.” A prompt nudge does not remove the wrong tool from scope.

Pattern 3: Silent-failure. The output passes JSON validation, no exception fires, no alert triggers, and the answer is still wrong. Nobody notices until a customer calls. The fix is the three-mechanism detection stack: assertion-based validators for business rules, a pinned golden set run on every change, and an LLM-as-judge layer. The trap answer is “add more logging.” Logging records the failure; it does not detect it.

Pattern 4: Cross-machine-portability. Works on your machine, breaks on the teammate’s. Environment drift. The fix is always scoping: a config in the wrong directory, a hardcoded path, an env var that lives only on your machine. Move the config to the scope that matches its intent. The trap answer is “the teammate has a different version.” Version skew is real but it is rarely the root cause.

Pattern 5: Trust-boundary. Untrusted input, an over-permissive grant, or a request the operator policy forbids. The flagship stem: “why would you NOT give Claude full access to your entire database?” The fix names blast radius first, then least-privilege scoping. The trap answer is “the terms of service prohibit it.” The exam grades architecture, not policy.

Why does pattern recognition beat memorization here?

Because the exam is closed-book and timed, and recall breaks under both. You get roughly two minutes per question. There is no Claude in the room, no docs tab, no man page. A study method built on flashcards trains recall, and recall is exactly what a tricky distractor and a 120-minute clock are designed to break.

Recognition holds up. When you see “passes schema validation but the answer is wrong, no alert fired,” you do not retrieve a fact. You match a shape: that is silent-failure, the fix is assertions plus golden set plus judge, the trap answer is “more logging.” The four options collapse to one before you have finished reading them.

This is my flat opinion: every CCA study guide selling a 120-question dump is selling the wrong product. The shelf is full of recall drills for an exam that punishes recall. A test-taker who scored 985/1000 said he drilled about 60 highly specific scenario questions to get the edge cases down. He was not memorizing answers. He was burning the pattern-to-fix mapping into reflex.

How do you build the recognition reflex?

You drill stems, not facts. Write the cheatsheet from the table above on one page: five rows, the stem cues, the one-line fix. Then run scenario stems against it cold. Read a stem, name the pattern out loud, state the fix, check yourself. Reps, not rereads.

RECOGNITION DRILL — one stem at a time

1. Read the stem twice. Do not look at the answers yet.
2. Match the cue words to a pattern (1-5).
3. State the one-line fix out loud.
4. Predict the trap answer before reading the options.
5. Only now read A/B/C/D. The architectural answer is the one
   that matches your fix. Eliminate the knob-turns.

The stems recycle. The exam writers reuse the same five shapes dressed in different customer voices and different domains. Drill the shape and a Domain 1 question and a Domain 5 question that share the silent-failure pattern stop feeling like two questions. They feel like the same rep you have already done.

Print this. Pin it next to the screen. It is the entire exam-day mental model on one card:

CCA SCAN-AND-MATCH CHEATSHEET

1 SCALE-FAILURE      at scale / p99 / latency / rate limits
                     -> Batch + cache + fallback
2 WRONG-TOOL-ROUTING right task / wrong tool / wrong call
                     -> tighten descriptions, scope subagent tools
3 SILENT-FAILURE     no alerts / looks fine / wrong answer
                     -> assertions + golden set + judge
4 PORTABILITY        works here / breaks there / env drift
                     -> scope the config
5 TRUST-BOUNDARY     untrusted input / over-permissive / blast radius
                     -> blast radius + least-privilege

Rule: name the pattern before you read A/B/C/D.
Recognition is a lookup, not a memorization.

What should you actually do?

• If you have 30 days and a partner-network seat → drill the five patterns first, then go domain by domain weighted to the 27/18/20/20/15 split. Domain 1 is the heaviest; earn it.
• If you keep failing practice mocks by a few questions → your gap is recognition speed, not knowledge. Stop rereading chapters. Drill stems against the one-page cheatsheet until the pattern lands in under ten seconds.
• If a study guide is selling you 120 trivia questions → it is training the wrong muscle for this exam. Use it for vocabulary only, not for judgment.
• If you can already name the pattern and the trap answer cold on every stem → you are ready to schedule. Book the date.

bottom_line

• The CCA exam is a pattern-recognition test wearing a multiple-choice costume. Treat it like one.
• Five patterns, five cue sets, five one-line fixes. That table is the whole mental model. Everything else is depth on top of it.
• Drill stems out loud against the cheatsheet until recognition is a reflex. Recall loses under a 120-minute closed-book clock; recognition does not.