CCA-F

Format

What you sit down to

source: pass reports from recent test-takers, jul–aug 2026

Official structure

Five domains

1. Agentic Architecture & Orchestration — agentic loops, multi-agent systems, subagents, hooks, sessions
2. Tool Design & MCP Integration — tool interfaces, structured errors, tool choice, MCP servers, built-in tools
3. Claude Code Configuration & Workflows — CLAUDE.md, skills & commands, plan mode, CI/CD
4. Prompt Engineering & Structured Output — system prompts, few-shot, JSON via tool use, validation loops, batch
5. Context Management & Reliability — context window, escalation, error propagation, provenance

Domain 1 of 5

Agentic Architecture & Orchestration

1. How an agent actually runs: the loop — reason → act → observe → continue, driven by structured signals, not by the model "deciding it's done"
2. When one agent isn't enough: multi-agent systems, subagents, and what context you pass them (they inherit nothing)
3. Keeping it under control: hooks, workflow enforcement, iteration caps, and sessions (resume vs fork)

Exam flavor: "design or debug a multi-agent research system."

Domain 2 of 5

Tool Design & MCP Integration

1. Giving Claude hands: designing tool interfaces — names, descriptions, and schemas the model can actually choose between
2. When tools fail: structured error responses — category, retryable or not, enough info to self-correct
3. Connecting to the world: MCP servers, tool distribution across agents, and Claude Code's built-in tools (Grep, Glob, Read, Edit, Bash)

Exam flavor: "the model keeps picking the wrong tool — what do you fix?"

Domain 3 of 5

Claude Code Configuration & Workflows

1. Persistent behavior: CLAUDE.md hierarchy and scoping, imports, path-specific rules — configuration instead of re-prompting
2. Reusable capabilities: slash commands and skills
3. Execution modes: plan mode vs direct execution, iterative refinement, and headless CI/CD integration

Exam flavor: "a team wants consistent Claude behavior across repos and pipelines."

Domain 4 of 5

Prompt Engineering & Structured Output

1. Getting reliable answers: system prompts with explicit criteriaand few-shot examples
2. Getting reliable data: JSON via tool use, andvalidation-retry loops when it doesn't conform
3. Doing it at scale: batch processing and multi-instance, multi-pass review

Exam flavor: "an extraction pipeline returns bad JSON — what's the next step?"

Domain 5 of 5

Context Management & Reliability

1. The context window is finite: managing it, compaction, and what survives summarization
2. Knowing when to stop: escalation to humans, ambiguity resolution, confidence calibration
3. Trustworthy output over long runs: error propagation between agents, context degradation, information provenance

Exam flavor: "a long-running agent starts forgetting or making things up — which pattern fixes it?"

Mental model

Think of them as layers

Learn them one layer at a time. Today is the map — not the territory.

Why people report "different topics"

Syllabus ≠ exam structure

That's why one test-taker reports "CI/CD, multi-agent, data extraction, MCP" and another "structured output, Agent SDK…" — they remember the story, not the domain number.

Six blocks per sitting — themes seen in pass reports

Scenario themes → domains

reported hardest: ci/cd and data extraction — "nothing like the mock exams"

Two tracks

Study the layers, drill the scenarios

Track 1 without Track 2 is the most common failure pattern.

Resources · Track 1

Where to learn the syllabus

1. claudecertificationguide.com/learn — the whole syllabus, domain by domain, unit by unit
2. Official prep courses — anthropic-partners.skilljar.com, the CCA-F prep collection + Exam Guide
3. Official docs — docs.claude.com: Claude Code, Agent SDK, MCP, prompt engineering

Pick one as your spine, use the others as reference.

Resources · Track 2

Where to drill

1. Official Exam Guide (Skilljar) — sample questions, section 9
2. certsafari.com — mock exam farm, domain mode
3. ccaf-mock-exams.onrender.com — community-built mocks, tuned to the real difficulty (harder end)
4. claudecertificationguide.com — theory + diagnostic test

rule of thumb from those who passed: if you pass the hard community mocks, you're ready

Domain 1 · Agentic — the loop

// The docs write this as: while (stop_reason === 'tool_use') — unbounded.
// A capped for is the same loop, worst case exactly MAX_ITERATIONS paid calls.
for (let i = 0; i < MAX_ITERATIONS; i++) {
  const response = await createMessage(params);

  // structured signal decides the flow — never the reply text
  if (response.stop_reason !== 'tool_use') {
    return { reply, applicant, step: advanceStep(input.step, applicant) };
  }
  // ...execute the requested tools, push results, go around again
}
throw new Error(`Agent exceeded maximum iterations (${MAX_ITERATIONS})`);

stop_reason is the control signal; the cap makes a confused model abounded cost, then a loud developer-facing failure.

Domain 2 · Tools — structured errors

export function toolError(category: ErrorCategory, message: string) {
  return {
    category, // transient | validation | business | permission
    // "calling again can ever succeed" — derived, never passed in
    isRetryable: category === 'transient' || category === 'validation',
    message,
  };
}

// a dissolved company is policy, not a bug — business, not retryable:
toolError('business',
  `${profile.company_name} is dissolved. Only active companies are eligible.
   Tell the applicant and ask if they have another company.`);

Four categories, isRetryable derived from the category — the model reads the payload and knows whether retrying can ever help.

Domain 3 · Claude Code — config over prompting

AGENT_CACHE=replay   # default — committed fixtures only, never the network
AGENT_CACHE=record   # call the real API once, write the fixture
AGENT_CACHE=off      # live calls, write nothing

# .claude/rules/api-conventions.md:
#   "Never construct an Anthropic client and never call
#    client.messages.create anywhere else."

Record/replay cache: a fresh clone runs offline, free, deterministic — the same property CI needs from claude -p. Rules live in config, not in every prompt.

Domain 4 · Structured output — schema + retry

// One Zod schema, two jobs — they can never drift:
{
  name: t.name,
  description: t.description,
  input_schema: toToolInputSchema(t.schema), // 1. the JSON Schema the model sees
}

const parsed = saveNameSchema.safeParse(block.input); // 2. validates what it sent
if (!parsed.success)
  return {
    content: JSON.stringify(zodFailureToToolError(parsed.error)),
    isError: true, // the model reads the error and corrects itself — retry loop
  };

JSON via tool use, validated on arrival; a failed parse becomes anis_error tool result — the validation-retry loop with no extra code.

Domain 5 · Context — what enters the transcript

// The server holds nothing between HTTP calls — anything that must
// survive to the next turn lives in the transcript itself.
const messages = [...input.messages];

// Trim before it enters the transcript: the registry returns every field
// it has, the model needs four — and this JSON rides along on every
// later call this turn. Verbosity compounds.
const trimmed = result.items.map((item) => ({
  title: item.title,
  company_number: item.company_number,
  company_status: item.company_status,
  address_snippet: item.address_snippet,
}));

Stateless server, transcript as the only memory, tool resultstrimmed at the boundary — context is a budget you spend on purpose.