Half reasoning, half memory

In short: CCAR-F is 60 questions over four scenarios. About half of it can be reasoned out with good engineering instincts. The other half is convention: a flag, a file path, a parameter value. You know it or you do not. So I study every concept twice: once by building it, and once by memorising its facts.

Good instincts will not tell you which of four flags is the real one. That is the whole problem with this exam, and this post is how I plan around it. The first post in this series covers which exam to take and who can sit it.

How the exam is built

• 60 questions in 120 minutes, closed book.
• Multiple choice, plus multiple response where the question tells you how many to pick.
• The pass mark is 720 on a scale of 100 to 1000, with no minimum per domain.
• The exam guide publishes six scenarios. You get four of them, with about 15 questions on each.

The six scenarios:

1. A customer support agent that resolves cases and escalates to a person.
2. Code generation with Claude Code.
3. A multi-agent research system with a coordinator and subagents.
4. Developer productivity with built-in tools and MCP.
5. Claude Code in continuous integration.
6. Structured data extraction.

One published review, from someone who passed, says the scenarios matter less than they look. The questions under them test specific concepts. So I organise my notes by concept and by domain, not by scenario.

The domains and their weights. Every task statement under them is on the CCAR-F page.

The reasoning half

This half is tool design, orchestration and error handling. If you have built APIs for years, you can often work out the answer.

I study it the same way for every concept:

1. Read one short section.
2. Predict what the code will do before I run it.
3. Build a small example, or break one on purpose.
4. Say it back in my own words.

My first note shows what this looks like. I built a chat app on the plain query() call, asked it what I had just asked, and watched it say it had no history. I read the fix after I had seen the bug.

The memory half

This half is closed-book recall. A few of the facts on my list so far:

• The stop_reason values, and which ones mean “run the tool” and “done”.
• The tool_choice options, and which one forces a tool call.
• .mcp.json in the project for shared servers, ~/.claude.json for personal ones.
• -p, --output-format json and --json-schema for running Claude Code in a pipeline.
• Message Batches: half the price, up to 24 hours, and no tool loop inside a request.

I study it with three habits. Every note ends with a block of exact facts. Every wrong answer goes on a list, grouped by domain. At the end, the blocks become one fact sheet.

Backend analogy: It is the difference between designing a retry policy and remembering which HTTP status code means “too many requests”. You can derive the first one. The second one you look up, and this exam is closed book.

Answer the guide, not the product

Claude Code ships changes faster than an exam guide can follow. So some answers that are right in today’s product are wrong in the exam.

One example. The exam guide says a coordinator needs "Task" in its allowed tools to spawn subagents. Anthropic’s SDK docs now call that tool Agent, and note that older versions named it Task. In the exam, the answer is Task.

Exam tip: Study the product to understand it. Answer the guide to pass. Where the two differ, my notes will say both.

My study order

Four phases, with the heaviest domains first. I publish a note when its session is done, so no dates are set.

The 21 notes I plan to write. This is a plan, so the list will change as I learn what needs more room.

The practice check

I take a practice set by domain after phase 2, not cold at the start. A score on material I have not studied tells me nothing.

What it shows becomes note 20, and it decides which earlier notes I revise. I will publish my scores by domain and the topics I missed. I will not publish real exam questions.

What a note looks like

Every note has the same parts, in the same order:

1. The answer, in two or three sentences.
2. The concept, with one analogy from backend work.
3. One picture.
4. What I got wrong.
5. The facts to remember.
6. Two or three questions to check yourself.

Parts 2 and 3 are for the reasoning half. Part 5 is for the memory half. Part 4 is the one nobody else can write for me.

Next in this series: the agent I built with the loop this exam tests.

Sources

• CCAR-F exam guide, Anthropic: the format, the six scenarios, the domains and the pass mark.
• Agent Factory crash courses, Panaversity, which I study from: https://agentfactory.panaversity.org
• Subagents in the Agent SDK, Anthropic, for the Task and Agent tool names: https://code.claude.com/docs/en/agent-sdk/subagents
• “The Claude certification exams: an honest review” by Matthew Purcell, 22 July 2026, for the half and half split and the point about scenarios: https://www.linkedin.com/pulse/claude-certification-exams-honest-review-matthew-purcell-byo2e/
• The study method, the order and the list of notes are mine.