Claude Certified Architect (CCAR-F): Complete Exam Prep

The running build starts here, and it starts deliberately small: the pull request reviewer becomes one agentic loop in a terminal, driven by stop_reason, and the lesson's whole argument is that for this job, one loop is the correct architecture and building more would be wrong.

A forty-file pull request dilutes the single loop's attention past usefulness, so this lesson splits the reviewer into a coordinator with three specialists, security, migrations, and API contracts, each with its own instructions and a short tool list.

The reviewer's correct warning ships anyway because everything it produces is advice, so this lesson puts three mechanisms into the build: a hook that gates the approval call, a structured handoff into Nadia's review queue, and a signature in the path on anything touching billing.

The reviewer in this course's running build could read a diff and nothing else, so it approved a rename that broke a service it never saw. This lesson decides how it reaches everything else: the built-in tools for the repository it lives in, then MCP servers for the tracker and deploy history the team does not own.

Three teams ran the running build's reviewer three different ways, a new hire got no conventions at all, and a test file got a database comment. This lesson decides where every rule lives, so the correct convention reaches every file on its own: a committed project file, path-scoped rules, and skills for the work that is not universal.

The running build's reviewer worked, and a payments change still merged at two in the morning because nobody was awake to type into it. This lesson takes the person out of the loop: what a run may do without being asked, plan mode against direct execution, and the one flag that puts the reviewer in the pipeline.

The running build's reviewer now runs on every pull request, it left nineteen comments on one of them, three were real, and the team filtered it out of their inboxes. This lesson decides what it reports and what it skips: a report list and a skip list instead of a confidence threshold, severity levels with a code example attached to each, and examples for the calls a competent engineer would have to think about.

The reviewer in this course's running build wrote a genuinely good verdict and Nadia's merge gate threw it away unread, so this is the lesson where the verdict stops being prose: it becomes a schema the gate can parse, a validation step compares the stated total against a calculated one, retries carry their specific errors back with them, and the overnight analysis moves to the batch route.

The reviewer that was excellent on a small repository this morning goes vague on the payments monorepo by hour two, so this is the lesson where the build learns to keep what it read: transactional facts move out of the summarized history into their own block, the verbose file reading moves into subagents, and findings land in a scratchpad with the paths they came from.

This lesson changes nothing in the running build; it changes the weeks before the day, because the guide prints all six situations the exam is built from, four of them are presented at random on your paper, and every word of that reading can be done at your desk in advance for nothing.

Nothing new gets built in the running build this lesson; it is the reading method for the paper itself, opening on the guide's own published sample where an option a good engineer would defend in a design review is marked wrong, and two words in the stem had already decided it.

The reviewer's fourteen-file report came back uneven and self-contradictory with no error anywhere, so this lesson decides where the work gets cut: into pieces that each get full attention and do not need to talk to each other.

The reviewer died mid-review and the only fix anyone had was a restart from zero, so this lesson decides what the system still has after something goes wrong: a recorded state a restart can resume from, and failures that arrive with enough context to act on.

No new material: the running build sits for seven exam-style questions, and this lesson decides the third read, the one you run when the stem carries no absolute and has already named its own cause.

The capstone walks the finished pull-request reviewer end to end in the order it was built, and at each of the eleven junctions it names the decision made, the architect question it answered, and the domain that scores it.