CCAR-F practice questions, answered and explained

A research agent must survey 40 vendor documents and produce a single comparison table. The documents are independent of one another, and coverage matters more than latency. Which orchestration structure best satisfies the requirement?

• A A single agent looping over all 40 of the documents inside one context window

Forty documents will exhaust a single context long before the table is written.

• B Parallel workers appending rows directly to the final table, with no synthesis step

Workers writing straight to the output produce inconsistent, overlapping rows with nothing to reconcile them.

• C A coordinator spawning parallel workers over subsets, then synthesizing their findings

Correct. Parallel workers give the coverage, and the coordinator's synthesis step is what turns 40 partial results into one coherent, de-duplicated table.

• D A sequential pipeline, passing each document's findings into the analysis of the next one

The documents are independent, so sequencing them buys nothing and makes the run forty times longer.

The documents are independent, so nothing is gained by sequencing them, and 40 documents will exhaust a single context. Parallel workers give coverage; the coordinator's synthesis step is what turns 40 partial results into one coherent, de-duplicated table. Workers writing straight to the output produce inconsistent, overlapping rows.

A coordinator fans out eight workers to survey different subsystems. Each worker returns several hundred lines of raw file contents, and the coordinator exhausts its context before it can synthesize. What is the design error?

• A The workers were given read access to a great many files they did not need

Excess read access is untidy but the coordinator's context is exhausted by what is returned, not by what was readable.

• B The coordinator should have used a pipeline so results arrived one at a time

Sequencing the same oversized returns exhausts the context just as surely, only more slowly.

• C Too many workers were spawned in parallel for one coordinator to absorb

Worker count is not the problem; eight compact conclusions would have fitted easily.

• D The workers return raw material rather than conclusions, defeating the isolation

Correct. Subagent isolation exists so bulk reading costs the coordinator only a conclusion, and returning raw contents moves the whole context problem upward.

Subagent isolation exists so that bulk reading costs the coordinator only a conclusion. A worker that returns raw file contents moves the whole context problem up to the coordinator. The fix is an output contract — findings, not transcripts. Sequencing the same oversized returns would exhaust the context just as surely, only slower.

A coordinator spawns a subagent with: "Read auth/session.py, then grep for validate_token, then open the tests, then report whether the refresh flow is safe." What is the primary architectural weakness?

• A The prompt is too long to fit inside a subagent's available context window

The prompt is short; length is not what makes it fail.

• B The coordinator should have done this work inline rather than delegating it out

Delegating the investigation is reasonable — how it was delegated is the problem.

• C The instruction is procedural, so it cannot adapt when step one proves misleading

Correct. Procedural delegation fixes the investigation path before any evidence is in, so a misleading first step still marches through the remaining ones.

• D The subagent has been granted rather more tools than its role actually requires

Tool count is not the flaw; the subagent could do this work with the tools it has.

Procedural delegation fixes the investigation path before any evidence is in. When the first file turns out to be a thin wrapper, the subagent still marches through the remaining steps and reports on the wrong code. A goal-oriented prompt — state the question and the required evidence — lets it follow what it finds.

A team moves to goal-oriented delegation and finds that subagents reach conclusions the coordinator cannot audit. What restores visibility without giving up adaptability?

• A Have the coordinator re-run each subagent's investigation for itself

Re-running each investigation in the coordinator discards the delegation entirely.

• B Return to procedural instructions, so that the path is known in advance

Reverting to procedure gives up the adaptability the team moved to goal-oriented delegation to gain.

• C Require each conclusion to come back with its evidence and its method

Correct. Goal-oriented delegation controls the destination rather than the route, so control is reasserted through the output contract.

• D Reduce each subagent's tool access, so that fewer paths are possible

Narrowing tools limits where the subagent can look without making its reasoning visible.

Goal-oriented delegation controls the destination, not the route — so control is reasserted through the output contract. Requiring evidence and method with every conclusion keeps the coordinator able to audit the reasoning while the subagent stays free to adapt its path.

An engineer asks Claude to migrate an application's authentication layer from server-side sessions to JWTs, touching roughly 30 files. Which review architecture fits best?

• A Plan mode, so the approach and blast radius are approved before any edit

Correct. Wide blast radius, real risk of breaking authentication, and a design decision the human owns is exactly the profile plan mode exists for.

• B Plan mode is unnecessary, since a review of the resulting diff is equivalent

Reviewing 30 files of auth changes after the fact is far more expensive than approving the approach up front.

• C Direct execution, since the change is mechanical once an approach is chosen

The approach is a design decision the human owns, and it is not settled before the work begins.

• D A multi-phase workflow with independent adversarial verifiers per file

Per-file adversarial verification is expensive and addresses precision, which is not the risk here.

Wide blast radius, a real risk of breaking authentication, and a design decision the human owns — that is exactly the profile plan mode exists for: read-only investigation, then an approved plan, then execution. Reviewing 30 files of auth changes after the fact is far more expensive than approving the approach up front.

A developer asks for a null check plus a covering unit test in one small, well-understood module. Which architecture is appropriate?

• A A coordinator-worker fan-out, one for the fix and one for the test

A fan-out over two trivial pieces of work adds coordination overhead for no gain.

• B Direct execution of both the check and the covering test

Correct. The change is narrow, low-risk, and fully specified, so planning and verification stages add ceremony without reducing risk.

• C Plan mode, since every code change should be approved first

Not every code change needs prior approval; architecture is chosen by scope and risk.

• D A multi-phase workflow with a separate verification pass

A separate verification pass costs several times as much for a change a test settles immediately.

Architecture is chosen by scope, risk, and approval need. This change is narrow, low-risk, and fully specified, so planning and verification stages add ceremony without reducing risk. Reserve plan mode and multi-phase workflows for work whose blast radius or uncertainty justifies them.

A synthesis subagent returns: "Found 3 issues. Details are in the file I mentioned earlier." Which principle did the coordinator's prompt violate?

• A Context scoping: the system prompt described far too broad a role for it

Role breadth would produce a vague answer, not a reference to a conversation the subagent never saw.

• B Output schema: the subagent should have been made to call a structured tool

A schema would change the shape of the answer without supplying the missing facts.

• C Self-sufficiency: the prompt must carry every finding the subagent needs

Correct. A subagent starts with a fresh context and sees only the prompt it was handed, so a reference to the coordinator's history points at nothing.

• D Tool restriction: the subagent was given Read access that it did not need

Read access is not the problem; the subagent had nothing to read because the reference was never resolved.

A subagent starts with a fresh context and sees only the prompt it was handed. "The file I mentioned earlier" refers to the coordinator's history, which the subagent never had, so it had nothing to report against. A schema would change the shape of the answer, not supply the missing facts.

You are prompting a verification subagent to test one claimed bug. What does its prompt need in order to complete without a round trip?

• A The claim, its exact location, the code itself, and the bar for refuting it

Correct. Verification needs the specific assertion, where to look, the material to look at, and a defined bar for refutation.

• B The claim, together with an instruction telling the verifier to be skeptical

Skepticism without evidence produces an opinion rather than a verdict.

• C The coordinator's own system prompt, so the verifier shares its standards

The coordinator's system prompt conveys standing behavior, not the claim under test.

• D The full list of all findings, so this one can be ranked against the others

The other findings are irrelevant to whether this one is real.

Verification needs the specific assertion, where to look, the material to look at, and a defined bar for refutation. Skepticism without evidence produces an opinion; the other findings are irrelevant to whether this one is real.

A codebase audit was interrupted after 60 of 90 modules. Some files changed while it was stopped. What is the correct resumption strategy?

• A Restart the audit from module 1, to guarantee a consistent snapshot

Restarting throws away sixty modules of completed work.

• B Ask the model to recall its earlier findings and continue on from there

A new session has no memory of the earlier one, so recall produces invention rather than state.

• C Inject prior findings, re-analyze the changed modules, then continue

Correct. Restore state without repeating work: inject prior findings, re-analyze only the modules whose files changed, then continue.

• D Resume at module 61 and ignore everything that was already completed

Blindly continuing keeps findings that the changed files may have invalidated.

Accurate resumption means restoring state without repeating work: prior findings are injected rather than re-derived, and only the changed files are re-analyzed, since their earlier conclusions are now stale. Blindly continuing keeps invalid findings; restarting throws away 60 modules of work; relying on recall is not state restoration at all.

In the context of session resumption, what does context injection mean?

• A Adding the previous session's identifier so history can be looked up

A session identifier is a label, not the state itself.

• B Increasing the size of the context window for the resumed session

Window size is a model property and has nothing to do with restoring prior state.

• C Loading the project's own CLAUDE.md file at the start of every new session

Standing project files provide guidance rather than prior findings.

• D Re-supplying completed units, findings, and open questions into the prompt

Correct. A resumed session starts with no memory of the prior one, so context injection is the deliberate act of putting the recorded state back into the prompt.

A resumed session starts with no memory of the prior one. Context injection is the deliberate act of putting the recorded state back into the prompt. Standing project files provide guidance, not prior findings, and a session identifier is not itself state.

You are configuring an automated Claude Code review that runs on every pull request and feeds a dashboard. Which configuration is correct?

• A Grant full tool access so failures can be reproduced, and return a prose summary

Prose breaks the consumer, and full tool access grants far more than reviewing requires.

• B Use the default settings and parse the reviewer's markdown output downstream

Markdown parsed downstream breaks silently whenever the formatting shifts.

• C Load the project standards, grant read and search only, and emit structured JSON

Correct. A downstream-consumed review needs the project's own standards loaded, tool access restricted to reviewing, and machine-readable output.

• D Load the standards but permit edits, so the reviewer fixes what it finds

Edit access turns a review into an unrequested change to the code under review.

A downstream-consumed review needs three things: the project's own standards loaded so findings match house conventions, tool access restricted to what reviewing requires, and machine-readable output. Prose and markdown break the consumer, and edit access turns a review into an unrequested change.

What does adding <code>context: fork</code> to a Skill or slash command's frontmatter do?

• A It clears out the whole conversation before the command begins running

The conversation is inherited rather than cleared, which is what lets the command act on what was established.

• B It duplicates the command so that it can be run twice over in parallel

Forking runs the command once, in isolation, rather than duplicating it for parallel execution.

• C It runs the command in an isolated context that inherits the conversation

Correct. The command executes in its own subagent context, inheriting the conversation while its intermediate work stays isolated and only the result returns.

• D It copies the current conversation into a new session the user can switch to

Nothing is copied into a new session the user can visit; the fork is internal to the command's execution.

A forked command executes in its own subagent context. Its intermediate tool calls and file dumps stay there; only the result comes back. That is what prevents a noisy command from polluting the main session's state.

An MCP server fronts a 400-page internal wiki. Agents burn many exploratory tool calls searching it before answering. What is the correct server-side change?

• A Rewrite the search tool's description so as to encourage fewer calls

A reworded description cannot make unaddressable content addressable.

• B Expose the pages as resources, so content is addressed and attached directly

Correct. Exploratory call storms are the signature of content exposed only behind tools, and resources make it addressable so it can be attached directly.

• C Increase the result limit on the search tool that already exists

A bigger result set makes each call heavier while the searching continues.

• D Add further search tools, each one scoped to a single section of the wiki

More search tools multiply the menu without removing the hunt.

Exploratory call storms are the signature symptom of content exposed only behind tools. Resources make server content addressable, so it can be attached directly instead of hunted for. More tools or bigger result sets make each call heavier without removing the hunt.

A server exposes <code>search_issues</code> and <code>search_pull_requests</code>. The agent routinely calls the wrong one. What is the correct fix?

• A Add a system prompt instruction telling the model to be careful of the two

A system-prompt reminder does not travel with the tool and is easily lost.

• B Merge the two of them into a single tool with a type parameter

Merging removes capability rather than ambiguity, and the type parameter inherits the same confusion.

• C Remove one of the tools, so the choice cannot be made incorrectly

Deleting a tool removes a capability the team presumably needs.

• D Rewrite both descriptions to state purpose, format, and when not to use each

Correct. Misrouting between semantically similar tools is a description problem, resolved by stating each tool's purpose, format, and when not to use it.

Misrouting between semantically similar tools is a description problem. Descriptions that draw the boundary explicitly — including when not to use this one, and how it relates to the neighbor — are what the model routes on. Merging or deleting removes capability rather than ambiguity, and a system-prompt reminder does not travel with the tool.

Your team needs an MCP server available to everyone who checks out the repository, authenticating with a key each developer holds privately. What is the correct setup?

• A Add it at project scope, referencing the credential by environment variable

Correct. Project scope makes the server travel with the repository, and environment variable expansion keeps the shared config free of secrets.

• B Add it at project scope and commit the key too, so setup is a single step

Committing the key leaks it to every clone, fork, and mirror.

• C Add it at user scope on each machine and document that in the README

User scope keeps the configuration on one machine, so teammates get nothing from the clone.

• D Add it at local scope, so each developer's configuration stays isolated

Local scope is the most isolated of all and leaves the server undiscoverable to the team.

Project scope is what makes a server travel with the repository for the whole team. Environment variable expansion keeps the shared config free of secrets while letting each developer supply their own. User and local scope leave the server undiscoverable to teammates; committing the key leaks it.

An extraction pipeline invents plausible phone numbers for documents that contain none. Which combination best addresses this?

• A Increase max_tokens, so the model is under no pressure to guess

More room to write does not create a way to say the value is absent.

• B Lower the sampling temperature down to zero for every extraction request

Deterministic sampling produces the same invented number more consistently.

• C Make the field nullable, instruct it to return null, and show an example

Correct. Fabrication happens when the schema offers no way to report absence, so make it representable, state the rule, and demonstrate it.

• D Add post-processing that discards numbers which fail a format check

Post-filtering discards real values along with invented ones and does not stop the invention.

Fabrication happens when the schema offers no way to say "not present." The fix is to make absence representable, state the rule, and demonstrate it with an example that actually exercises the missing case. Temperature and token limits do not create a slot for absence, and post-filtering discards real values too.

A <code>payment_terms</code> enum lists NET_30, NET_60, and DUE_ON_RECEIPT, but some contracts state terms outside that set. What is the correct schema design?

• A Keep the enum, add an OTHER member, and capture the raw wording

Correct. The enum keeps downstream values clean, while an OTHER member plus captured raw text gives the model a truthful place for anything unlisted.

• B Keep the enum and have the model choose the closest available member

Forcing the closest match silently corrupts data with a term the contract never stated.

• C Add every term encountered so far as a new member of the enum

Chasing each new term keeps the enum permanently behind the documents.

• D Drop the enum entirely and accept free text for the field instead

Free text throws away the constraint that keeps downstream values clean.

The enum keeps downstream values clean; OTHER plus captured raw text gives the model a truthful place to put anything unlisted, and preserves the evidence for review. Forcing the closest match silently corrupts data, and free text throws away the constraint entirely.

You must explain how authentication works in an unfamiliar 3,000-file repository, and context is limited. What is the correct exploration sequence?

• A Use Bash to concatenate the repository and read it all in a single pass

Concatenating the repository is the largest possible context cost for the least targeted result.

• B Read the README and the package manifest, then answer from those two

Manifests describe dependencies and entry points, not how the code behaves.

• C Glob for the paths, Grep for key symbols, then Read only what is central

Correct. Narrow before reading: locate candidates by pattern, find the symbols that matter by content, and spend context only where the evidence points.

• D Read every file under the auth directory in full before concluding

Reading a whole directory exhausts context on files that may have nothing to do with the answer.

Systematic exploration narrows before it reads: locate candidate files by pattern, find the symbols that matter by content, and spend context only on the files the evidence points to. Reading whole directories or the whole repository exhausts context; manifests alone do not describe how the code behaves.

You need every file in the repository whose name matches <code>*.test.ts</code>. Which built-in tool is correct?

• A Grep, searching the file contents for the string ".test.ts"

Content search would match unrelated references to that string inside files.

• B Glob, matching against the filename pattern directly

Correct. Glob is the tool for locating files by name pattern.

• C Bash, running a find command across the repository

Shelling out to find duplicates a built-in with worse integration.

• D Read, opening each of the directories in turn

Read does not enumerate directories.

Glob is the tool for locating files by name pattern. Grep searches contents and would match unrelated references to the string; shelling out to find duplicates a built-in with worse integration; Read does not enumerate directories.

You are wiring Claude Code into a CI pipeline that must never block on a prompt and must fail rather than run away. Which invocation shape is correct?

• A Print mode with structured output, a turn limit, and a tool allow-list

Correct. Print mode with structured output, a turn limit, and a tool allow-list gives all three properties: no blocking, parseable output, and a hard ceiling.

• B Interactive mode with a generous timeout, so a human can step in

Interactive mode blocks on a prompt that nothing in CI will answer.

• C Print mode with every permission check bypassed, so nothing stalls

Bypassing every permission check removes the guard rails instead of the prompts.

• D Interactive mode with the output piped to a file for later inspection

Redirecting output does not stop an interactive session from waiting for input.

CI needs three properties: no prompt can block the run, the output can be parsed by the next step, and the run has a hard ceiling. Print mode with structured output, a turn limit, and a tool allow-list gives all three. Bypassing every permission check removes the guard rails instead of the prompts, and interactive mode blocks.