How to Study for the Claude Certified Architect Exam

Summary:

1. Weighted prep beats random drilling: study where the points actually live.
2. Build a scorecard, take one weighted diagnostic, and score each of the five domains separately.
3. Attack the domain furthest below 75% first, not the one you already like.
4. You get a portable readiness map that turns the rest of your prep into a plan.

Claude Certified Architect exam prep goes wrong the same way for almost everyone: you grind whatever free questions you can find, in whatever order they show up, and hope the average is good enough. The free banks contradict each other on difficulty, so you never learn which domain is actually about to cost you the exam. The fix is not more questions. It’s a weighted diagnostic that names your weak spot before you waste a week on the wrong domain.

Why does random drilling fail?

Because the exam is not an even five-way split, so studying it evenly wastes your best hours. The five domains carry different weights, and a point you leak in the heaviest domain costs more than a point in the lightest. Here is the reported blueprint, by name, in descending weight:

If Agentic Architecture is leaking, you’re bleeding points where the exam pays the most. That table is your map. Random drilling ignores it.

How do you find your weakest domain?

Build a scorecard first, then take one diagnostic weighted to that split. The scorecard is the instrument you fill for the rest of your prep. Copy this into a file:

DOMAIN-READINESS SCORECARD
Domain                                   Weight  Score%  Target  Status
Agentic Architecture & Orchestration      27%      __     75%      _
Claude Code Configuration & Workflows      20%      __     75%      _
Prompt Engineering & Structured Output     20%      __     75%      _
Tool Design & MCP Integration              18%      __     75%      _
Context Management & Reliability           15%      __     75%      _

Then take a 40-question diagnostic that mirrors the weighting: roughly 11 Agentic, 8 Claude Code, 8 Prompt, 7 Tool and MCP, 6 Context. Take all forty in one sitting, closed-book, about 80 minutes so you feel the two-minutes-a-question clock. The questions are scenario-judgment, like this one:

A coordinator is configured with three subagent definitions in its `agents`
parameter. It runs without error, but it answers every query itself and never
delegates. Its allowed_tools is ["Read", "Glob", "Grep"]. The fix?
  A. Switch the coordinator to a more capable model.
  B. Add more detail to each subagent's description field.
  C. Add "Agent" to the coordinator's allowed_tools.
  D. Move the subagent definitions into .claude/agents/ files.

(The answer is C: delegation is gated by the Agent tool, not the model.) Score each domain as a percentage of that domain’s questions, and you get a readiness map.

DOMAIN-READINESS MAP (from the 40-question diagnostic)
Domain                                   Right/Total  Score%  Gap below 75%
Agentic Architecture & Orchestration        __ / 11     __        __
Claude Code Configuration & Workflows        __ / 8      __        __
Prompt Engineering & Structured Output       __ / 8      __        __
Tool Design & MCP Integration                __ / 7      __        __
Context Management & Reliability             __ / 6      __        __

One honest rule about that 75% line. It is a drill bar: the score you want on a set before you move on. It is not the pass mark. The real exam scores you on a scaled 100 to 1000 range with a 720 pass line, and a scaled score does not convert cleanly to a raw percentage. You can miss questions and still pass. Use 75% to rank your weak spots and pace your drilling, never to tell yourself “I’d pass.”

What should you drill first?

Rank the domains by how far each sits below 75%, and the biggest gap is where you start. Because Agentic Architecture is the heaviest domain, it deserves the largest drill block, and most of its judgment reduces to recognizing which composable pattern a scenario calls for. The people who built Claude name five:

Source: Anthropic, Building effective agents. A large share of Agentic Architecture questions is a scenario that maps to exactly one of these five. Learn to name the pattern on sight and the heaviest domain gets a lot lighter.

What broke when people prepped by volume?

Volume prep is why high practice scores collapse on the real exam. Passers report the same painful gap: one went from 766 on a first practice test to about 950 on the official practice two days out, then 843 on the real exam. Another scored 980 in practice and 744 live. The banks that inflate your score test recall; the exam tests judgment.

The defense is a miss-log. Every time you miss an item, log one line, and pay attention to the trap column, because it tells you the shape of the mistake you keep making:

MISS-LOG
Item / Mock   Domain              Sub-skill exposed        Trap I fell for
-----------   -----------------   ----------------------   -----------------
Q7 diag       Agentic             effort scaling           constrain-don't-add

When three misses share a trap, that pattern is your real weak spot, not the individual questions.

What should you actually do?

• If your diagnostic scores are all close → drill the heaviest domain first (Agentic, 27%); it moves your scaled score most.
• If one domain is far below the rest → start there regardless of weight; a single domain in the 40s drags your whole readiness down.
• If a free bank tells you you’re at 95% → distrust it and re-take a weighted diagnostic; calibration matters more than the number.
• If you keep missing items in one domain for the same reason → drill the trap, not the topic. The miss-log tells you which.

The bottom line

• Weighted prep beats even prep. Score each domain separately and attack the biggest gap, not your favorite topic.
• 75% is a drill bar, not the 720 pass line. Confusing the two is how people walk in over-confident.
• Agentic Architecture is 27% of the exam and mostly pattern recognition. Learn the five patterns cold and the heaviest domain stops being scary.