When I started preparing for the Claude Certified Architect Foundations (CCA-F) exam, the first thing that surprised me was how many people were studying for it the way you'd study for a generic LLM cert: heavy on prompt engineering tricks, light on the actual architecture material.
The published blueprint tells a different story. If you let the weights drive your hours instead of your comfort zone, you end up with a very different study plan than the one most candidates are running.
This is the plan I'd give myself if I were starting over. It's six weeks, roughly 6–8 hours per week, and it's organized around the actual blueprint, not vibes.
The CCA-F is a 60-question, 120-minute exam. Scoring is scaled 100–1000, with 720 to pass. The blueprint is split across five domains:
The single most useful thing I can tell you is this: Agentic Architecture is the largest domain, and it's the one most engineers under-prepare on. Prompt Engineering feels familiar, so it absorbs disproportionate study time. Agentic Architecture feels abstract, so it gets skipped until the last week. Reverse that instinct.
A quick sanity check on hour allocation across six weeks at ~7 hours/week (42 hours total):
Now the week-by-week plan.
Goal: stop thinking about Claude as a chat completion endpoint.
The core mental model you need is the agent loop: the model emits a response, the runtime inspects stop_reason
, dispatches tool calls if needed, appends results back into the conversation, and re-invokes the model. That loop is the unit of work the exam tests, not the single API call.
Things to be solid on by end of week 1:
stop_reason
(end_turn
, tool_use
, max_tokens
, stop_sequence
) and what the orchestrator should do in response to each one.tool_result
blocks to the conversation history rather than re-prompting from scratch.end_turn
, explicit user interrupt).A useful exercise: sketch the pseudocode for an agent loop on paper, without looking. If you can't write the while
loop and the stop_reason
branches from memory, you're not ready to move on.
while True:
response = client.messages.create(
model=model,
messages=history,
tools=tools,
max_tokens=4096,
)
history.append({"role": "assistant", "content": response.content})
if response.stop_reason == "end_turn":
break
if response.stop_reason == "tool_use":
tool_results = run_tools(response.content)
history.append({"role": "user", "content": tool_results})
continue
if response.stop_reason == "max_tokens":
break
That snippet is the spine of half the Agentic Architecture domain.
Now layer on the failure modes the exam loves to ask about.
tool_use
blocks in one turn, the runtime executes them in parallel and returns all results before the next model call.Then pivot into Context Management, which is the smallest domain (15%) but heavily intertwined with Agentic Architecture. Focus on:
This is the domain where engineers with strong backend backgrounds tend to overestimate themselves.
The trap: you already know how to write a good function signature for a human caller. Writing a good function signature for an LLM caller is a different discipline. The model is reading your description as part of its decision about whether and how to invoke the tool.
Key things to internalize:
"error: bad input"
as a string teaches the model nothing. A tool that returns a structured error with a code
and a hint
lets the model self-correct.do_everything
tool with a mode
parameter is almost always worse than three narrow tools.If you only do one exercise this week: take a tool you'd normally write for a REST client, and rewrite the schema and description as if the caller were an LLM that has never seen your codebase.
Claude Code is 20% of the exam and it's the most concrete domain. Things to be comfortable with:
CLAUDE.md
files and how project-level instructions compose with user-level instructions.Prompt Engineering, also 20%, is the domain where most candidates over-prepare. You don't need clever jailbreaks or 50 prompt patterns. You need:
The exam is not asking you to write clever prompts. It's asking you to choose the right prompting strategy for a given scenario.
Take a full 60-question, 120-minute timed simulation under exam conditions. No notes, no Claude open in another tab. Then score it by domain.
The pattern you're looking for is not your overall score. It's your lowest-scoring domain weighted by blueprint percentage. A 60% in Agentic Architecture costs you more points than a 60% in Context Management.
Spend the rest of the week drilling whichever domain has the worst weighted gap. Don't review what you already know.
Take a second full mock early in the week. Compare to week 5. If your weighted-worst domain hasn't moved, that's where the remaining hours go.
The last two days should be light. Re-read your own notes, not new material. Sleep more than you study.
If you want to drill against blueprint-weighted scenarios while you work through this plan, the practice platform I maintain at claudecertifiedarchitect.dev has a free 15-question set across the five domains (it emails you a diagnostic at the end). It's independent and not affiliated with Anthropic, but the question distribution mirrors the official blueprint, which is the thing that matters most for calibration. The full bank is 1,000+ questions, $24.99 one-time.
Good luck. Study the weights, not your comfort zone.