15 Free Claude Certified Architect – Foundations (CCAR-F) Practice Questions with Answers (2026)

Direct execution suits small, well-scoped changes with a clear cause. Plan mode earns its overhead on large changes, architectural decisions, or tasks with several valid approaches.

• A is wrong because it adds exploration and design time to a change that has neither.
• B is wrong because there is no verbose discovery phase to isolate; the stack trace already locates the problem.
• C is wrong because the interview pattern helps in unfamiliar domains with open design questions, not for a known one-line bug.

The agent can only recover well if it can tell failure types apart. A timeout is transient and worth retrying. A non-existent order is a valid empty result and should not be retried. MCP's isError flag plus structured metadata gives the agent what it needs.

• B is wrong because hiding failures as empty successes stops any recovery and misleads customers.
• C is wrong because one generic message, however long, still does not say which case happened.
• D is wrong because killing the session on a single tool failure is an anti-pattern when recovery is possible.

A required field pushes the model to produce something even when the source is silent. Making it nullable, with a clear rule for absent data, removes that pressure while keeping the field when it does exist.

• A is wrong because a general instruction does not remove the schema's demand for a value.
• B is wrong because retries cannot recover information that is not in the document, and a fabricated number can still pass a regex.
• D is wrong because you lose the value on the 70% of invoices that have one.

When a lookup returns several matches, the agent should resolve the ambiguity with the customer rather than guess. A wrong guess here can expose another person's data or apply a refund to the wrong account.

• A is wrong because a heuristic choice is still a guess, and "usually right" is not acceptable for account actions.
• B is wrong because it is a different heuristic with the same problem.
• C is wrong because the agent can resolve this itself with one question; escalating every case hurts first-contact resolution.

Each subagent starts with its own fresh context. If the coordinator does not put the findings in the prompt, the synthesis subagent never sees them. Passing them as structured data, with content separated from source metadata, also preserves attribution. (The exam guide calls the subagent-spawning tool "Task"; the current Agent SDK docs name it "Agent". The behaviour is the same.)

• A is wrong because a bigger model cannot cite research it was never given.
• B is wrong because the research itself was fine; the problem is the handoff.
• D is wrong because it duplicates work and gives a synthesis agent tools outside its role.

Grep searches file contents for a pattern. Glob matches file paths by name pattern. Match the tool to the question: "which files contain this text" is Grep, "which files have this name" is Glob.

• B is wrong because Glob matches paths, not contents.
• D is wrong because reading everything up front wastes context; start with targeted search, then read what matters.

context: fork runs the skill in its own subagent context. The verbose work stays there and only the result comes back, which protects the main session's context.

• A is wrong because it loads the audit instructions into every session, adding context instead of isolating it.
• C is wrong because clearing also throws away the work developers wanted to keep.
• D is wrong because the problem is what fills the session's context, not the output limit.

Worst case, a document arrives just after a submission and waits a full interval, then the batch takes the full 24 hours. The interval plus 24 hours must be 36 hours or less, so the interval can be at most 12 hours.

• A is wrong because it meets the deadline but is not the longest safe interval.
• C is wrong because 24 hours of waiting plus 24 hours of processing is 48 hours.
• D is wrong because it leaves no time for processing.

A hook gives a deterministic guarantee. Normalising data in code, before it reaches the model, removes the chance of a misread. Prompt-based fixes only make the right answer more likely.

• A is wrong because it still relies on the model converting formats correctly every time.
• B is wrong for the same reason: better odds, no guarantee.
• C is wrong because model size does not fix inconsistent inputs, and the return-window rule needs to be reliable.

.mcp.json supports environment variable expansion, so the shared config stays in version control without secrets. Each developer supplies their own credential. Also rotate the token that was committed.

• B is wrong because it removes the shared team configuration that project scope exists for.
• C is wrong because CLAUDE.md is also committed, so the secret is still in the repository.
• D is wrong because anyone with repository access, now or later, can still read the token.

Specific, categorical criteria improve precision far more than vague instructions. Turning off the high false-positive category quickly restores trust in the categories that matter.

• A is wrong because vague confidence instructions do not change what the model considers worth reporting.
• B is wrong because self-reported confidence is poorly calibrated, so the filter is unreliable.
• D is wrong because the problem is what gets reported, not how well it is written.

When most of the earlier tool results are stale, starting fresh with a summary of the conclusions is more reliable than resuming. Resuming makes sense when the earlier context is mostly still valid, or when you can point to a few specific changed files.

• A is wrong because the session would reason from file contents that no longer exist.
• C is wrong because a fork inherits the same stale baseline.
• D is wrong because compacting summarises the stale results; it does not refresh them.

Giving the reviewer its earlier findings lets it skip what is already reported and mark what is still open. The structured JSON output then posts only what is new.

• A is wrong because it erases the review history and any discussion on those comments.
• B is wrong because batches are for latency-tolerant work, and a PR review usually blocks merging.
• C is wrong because later commits would never be reviewed.

Preserving which source said what, and when, lets the report show that the difference may be a change over time rather than a contradiction. Readers then see both values with their sources.

• B is wrong because it is an arbitrary rule that hides real disagreement.
• C is wrong because averaging figures from different years creates a number neither source supports.
• D is wrong because it throws away useful, well-sourced information.