How to prepare by building

What you will be able to do

• Build four artefacts that cover the five exam domains between them
• Choose what to build first based on which domain you are weakest in
• Use this guide and the exam simulator as separate tools with separate jobs
• State the limits of an independent question bank and study accordingly

The exam asks for judgement about tradeoffs, and judgement comes from having made the tradeoff badly at least once. You can read that a tool description should state when to call a tool as well as what it does, and still choose the wrong repair on a scenario item. You will not make that mistake twice after watching a model call the wrong one of your two similarly described tools while you sit looking at the transcript.

So the plan is to build four things. Between them they touch all five domains, and none of them is large: each is an evening or two of work, deliberately small enough that you keep going back and changing it.

Artefact 1: an Agent SDK agent with a real tool loop#

Build a small agent on the Claude Agent SDK (claude-agent-sdk in Python, @anthropic-ai/claude-agent-sdk in TypeScript) that does one useful job end to end. The requirements that make it educational are the unglamorous ones: give it at least three tools whose purposes genuinely overlap at the edges, make one of them fail sometimes, and handle that failure rather than crashing.

Then break it on purpose. Rename a tool to something vague and watch the selection degrade. Return an unstructured error string and see how the agent responds compared with a structured one that says what went wrong and what to try instead. Add a second agent and delegate part of the work, so you see for yourself what a subagent does and does not inherit.

Covers domain 1 heavily, domain 2 substantially and part of domain 5.

Artefact 2: a fully configured Claude Code workspace#

Take a real repository, ideally one with more than one language or more than one clearly separate area, and configure it properly. That means a CLAUDE.md that carries the conventions someone joining the project would need, narrower rules scoped to the directories they apply to rather than to everything, and at least two custom slash commands for tasks you actually repeat.

Then use it for a week of ordinary work, and pay attention to the moments where you reach for plan mode and the moments where it just slows you down. Domain 3 questions about plan mode versus direct execution are easy to answer from experience and almost impossible to answer convincingly from theory.

Exact file locations and command formats belong to the version of Claude Code you have installed: check the current documentation rather than trusting a path you read somewhere, including here.

Covers domain 3 almost entirely, and gives you the CI scenario for free once you point the same configuration at a pipeline.

Artefact 3: an MCP server with differentiated tools and structured errors#

Write a small Model Context Protocol server exposing four or five tools over some data you care about. The two design decisions worth labouring are the ones the exam keeps returning to.

First, differentiation. Tools whose descriptions could be swapped without either becoming false are tools the model will confuse. Make each description say when to reach for it, and say what it does not cover.

Second, errors. A tool that fails should return something the model can act on: what went wrong, whether retrying will help, and what a sensible next step would be. Compare that against a bare exception message by running the same broken request through both.

Then connect the server to Claude Code as well as to your agent, so you have seen MCP from the client side in two places rather than one.

Covers domain 2 almost entirely, and reinforces the error-propagation half of domain 5.

Artefact 4: a structured extraction pipeline with validation and retry#

Take fifty documents of a kind that varies, invoices, job adverts, meeting notes, and extract them into a JSON schema you have defined. Enforce the schema, validate the result against rules the schema cannot express, and feed validation failures back for a bounded number of retries.

The learning is at the edges. Decide what happens to a document the pipeline cannot handle confidently, and make sure that decision is visible rather than silent. Try a batch strategy and watch where it helps and where it makes a single bad document expensive. Add a rough confidence signal and check whether it correlates with the errors you actually see, which it often does not on the first attempt.

Covers domain 4 almost entirely, plus the human-review and confidence material in domain 5.

Using this guide and the simulator#

They do different jobs, and using them in the wrong order wastes both.

The guide is for building a model of each domain. Read a unit, then go and change the relevant artefact so the idea has somewhere to land. A lesson read and never applied is the kind of knowledge that produces a confident wrong answer under time pressure.

The exam simulator is for two things: rehearsing the format, and finding out where your errors cluster. Timed runs are worth doing at least twice before the real sitting, because ninety seconds of thinking per item is a real constraint and discovering that on exam day is expensive.

The most useful review habit is to write down, for every item you get wrong, which of the four distractor types caught you: the right idea at the wrong layer, the fix for a problem the system did not have, the oversized change, or a genuine knowledge gap. After thirty or forty items the pattern is usually obvious, and it points at the artefact you should go back and break again.

A reasonable sequence#

If you have four to six weeks, a workable order is: build artefacts 1 and 2 first, since domain 1 is the heaviest and domain 3 is the most learnable; read the corresponding modules while you have the code open; then build artefacts 3 and 4 and read domains 2, 4 and 5 against them. Save timed simulator runs for the last stretch, when a poor result is diagnostic rather than discouraging.

Whatever the schedule, check the official CCAR-F exam guide from the Claude Certification Program before you book. The logistics in this guide were accurate when written, and the credential is valid for twelve months precisely because this material does not sit still.