Claude Exam Task Statements: CCAR-F Domain Guide

The 30 claude exam task statements map every CCAR-F question to a specific, testable skill. Learning to read them is the fastest route to focused preparation and the surest way to avoid wasted study time.

The Claude Certified Architect, Foundations exam (CCAR-F) organises its 60 scenario-based items around five domains and 30 task statements. Each question anchors to at least one task statement; high-weight domains produce proportionally more questions per sitting. Before diving into practice exams, download the official task statement list from Anthropic's certification portal to confirm the version you are studying.

What are the CCAR-F task statements?

Task statements are the atomic skill descriptors that make up each exam domain. They describe what a Claude Partner Architect must be able to do, not merely recall. A task statement in Domain 1 might require you to identify the correct fix when an agentic loop anti-pattern causes premature termination. One in Domain 2 might ask you to diagnose a tool misrouting problem given a description that is too broad to guide tool selection.

Because every item is scenario-based, task statements read as judgment tasks: "evaluate", "diagnose", "select", "design". Memorising definitions will not pass the exam. You need to apply each task statement to a realistic situation under time pressure, with plausible wrong answers that reflect common architectural mistakes.

How are the five domains and their task statements weighted?

The CCAR-F has five domains, each containing a cluster of task statements. Domain weights determine roughly how many of the 60 questions will test skills from each cluster.

Domain 1 at 27% is the single largest domain, making its task statements the highest-return study target. Domain 5 at 15% is the smallest, but its task statements on context reliability appear inside multi-domain scenarios, so gaps there compound. Anthropic does not publish the raw-to-scaled score conversion, so the approximate question counts are illustrations based on 60 items times stated percentages; your actual sitting draws 4 scenarios at random from a bank of 6.

Which task statement areas carry the most weight in Domain 1?

Agentic Architecture & Orchestration at 27% is the dominant domain. Its task statements cover:

• Designing the agentic loop around stop_reason so the model continues, terminates, or escalates correctly rather than hitting an arbitrary cap
• Choosing between hub-and-spoke architecture and flat multi-agent topologies based on coordination complexity
• Diagnosing narrow decomposition failure when a coordinator splits a task into pieces that cannot reassemble coherently
• Selecting parallel subagent spawning versus sequential execution when latency and error isolation requirements differ
• Enforcing constraints via hooks versus prompts using the hooks vs. prompts decision framework

A common exam pattern: you are given a multi-agent research pipeline where the coordinator spawns three subagents, one fails silently, and the synthesis step produces a confident but incomplete answer. The task statement asks you to identify the correct architectural fix. The answer is almost never "add a retry loop" as a first move; it is to surface structured error metadata so the failure is visible before synthesis begins.

What does the exam test in Domain 2 task statements?

Domain 2 covers Tool Design & MCP Integration at 18%. Its task statements focus on:

• Writing tool descriptions that function as a selection mechanism, guiding Claude to the right tool without ambiguity
• Deciding when to split a broad tool into narrower variants rather than patching the description
• Configuring tool_choice appropriately versus fixing the underlying tool design
• Scoping MCP servers to the right level in the MCP scoping hierarchy
• Handling the four error categories correctly via the isError flag

The exam will not ask you to recite tool_choice parameter values from memory. It will present a scenario where the model consistently routes to the wrong tool and ask which fix to apply first. The task statement tests whether you reach for the low-effort, high-leverage solution before reaching for configuration.

Here is the pattern of a tool description the exam expects you to flag as broken:

Tool name: search
Description: Searches things and returns results.

And the corrected form the task statements reward:

Tool name: web_search
Description: Queries the public web for current information not in the model's
training data. Use when the user asks about events after the knowledge cutoff,
real-time prices, or live URLs. Do NOT use for internal document retrieval.

The difference is not stylistic. A vague description produces systematic misrouting at scale; a scoped description with explicit exclusions narrows the model's tool selection to the intended use case.

How do Domain 3 task statements differ from the others?

Claude Code Configuration & Workflows at 20% has a practical, operational flavour. Its task statements ask you to:

• Navigate the three-level configuration hierarchy (user, project, and system) and identify which layer takes precedence when they conflict
• Choose between CLAUDE.md, .claude/rules/ path-scoped files, skills, hooks, and permissions for a given guidance scenario
• Design hooks for deterministic enforcement where prompt-based instructions would be insufficient or unreliable
• Set up CI/CD pipelines using Claude Code in headless mode for automated workflows

These task statements lean toward system-level thinking. When the exam presents an organisation-wide compliance requirement, such as preventing secrets in commit messages, the correct answer is a hook, not a system prompt instruction. The task statement is testing whether you understand the reliability gap between advisory text and enforced behaviour. An instruction in a prompt can be overridden or forgotten; a hook runs deterministically on every relevant event.

What makes Domain 4 task statements particularly testable?

Domain 4 covers Prompt Engineering & Structured Output at 20%. Its task statements include:

• Constructing few-shot examples that close the gap between intended and actual model behaviour for ambiguous edge cases
• Designing JSON schemas to prevent fabricated fields in extraction workflows
• Adding a validation loop before downstream consumption of structured output
• Choosing between goal-based and step-based prompts based on task complexity and the degree of procedural constraint required

This principle runs through Domain 4 task statements directly. A structured output scenario typically involves an extraction pipeline where Claude occasionally fabricates a field the schema does not define. The task statement rewards candidates who add schema validation before the pipeline's next stage rather than prompting Claude to "be more careful", because the latter is probabilistic and the former is enforceable.

# Exam-preferred pattern: validate before consuming structured output
import json
import jsonschema

def extract_and_validate(raw_output: str, schema: dict) -> dict:
    parsed = json.loads(raw_output)
    jsonschema.validate(parsed, schema)  # raises ValidationError on fabricated fields
    return parsed

The exam will not ask you to write this function from memory. It will present a pipeline description and ask which architectural change most reliably prevents fabricated-field errors reaching downstream consumers.

How do Domain 5 task statements appear across multi-domain scenarios?

Context Management & Reliability at 15% is the smallest domain, but its task statements appear inside scenarios that are nominally classified under Domain 1 or 4. When a long-running agent degrades in quality after many turns, that is a context management failure even if the scenario is labelled as an agentic architecture question.

The key task statements in this domain cover:

• Recognising context degradation in extended sessions and distinguishing it from model capability limits
• Choosing between summary injection, fresh session start, and session forking based on current task state and the cost of lost context
• Avoiding the stale context problem when resuming long investigations after interruption

Candidates who treat context as a first-class resource rather than an implementation detail consistently perform better on multi-domain scenarios that mix Domain 1 and Domain 5 task statements.

How should you map your study plan to task statements?

A task-statement-first study plan runs as follows:

1. Download the official CCAR-F exam guide from the Anthropic certification portal.
2. For each of the 30 task statements, write a one-sentence description of what a correct answer looks like.
3. Find at least one anti-pattern for each task statement (what wrong answers look like and why they fail).
4. Work through scenario-based practice questions and tag each question to the task statement it tests.
5. Use your domain-level score report to identify which task statement clusters still need work.

Our concept library at /concepts covers 174 atomic concepts mapped to all five CCAR-F domains and 30 task statements. Each concept page cross-references the task statements it supports, so a low score in Domain 2 leads you directly to the specific concepts underlying those task statements rather than to a broad domain review.

The platform's adaptive engine uses Bayesian Knowledge Tracing with a 0.90 mastery threshold. It will not mark a task statement cluster as ready until your answer pattern is consistent across multiple question variants, not just lucky on one attempt.

The CCAR-F passing score is 720 on a 100 to 1000 scale. Anthropic does not publish the raw-to-scaled conversion, so focus on task statement mastery rather than trying to count minimum correct answers.

What anti-patterns appear most often across task statement questions?

The exam's most testable anti-patterns cluster around five failure modes that cut across multiple domains:

Recognising these anti-patterns as wrong answers is a skill the task statements test directly. Scenario questions are written so that the anti-pattern option sounds reasonable; the task statement tests whether you know why it fails, not just that it does.