Practice Free CCAR-F Claude Certified Architect – Foundations Exam Questions Answers With Explanation

The document contains multiple factually valid values whose applicability depends on chronology and legal context. Collapsing those values into a single scalar field discards essential provenance. Option B corrects the data model by representing each term as a structured record containing the extracted value, source location, document or amendment identifier, and effective date.

Anthropic’s Structured Outputs feature is designed for data-extraction use cases in which nested objects and arrays must conform to a defined JSON Schema. ( https://platform.claude.com/docs/en/build-with-claude/structured-outputs ) Anthropic also recommends grounding factual outputs in direct source material and making claims auditable through supporting evidence. ( https://docs.anthropic.com/en/docs/test-and-evaluate/strengthen-guardrails/reduce-hallucinations ) A provenance-aware schema applies both principles: it retains the original clause and the amendment instead of forcing Claude to resolve a potentially complex legal precedence question during extraction.

Option A is destructive because removing superseded text prevents auditing and may eliminate terms still relevant to earlier periods. Option C oversimplifies amendment logic; the newest document is not automatically controlling for every date, jurisdiction, or clause. Option D identifies risk but does not improve the extracted representation and unnecessarily sends all amendment cases to manual review.

After extraction, deterministic business logic can select the value effective on a requested date while retaining the complete contractual history.

Official references/topics: Structured Outputs; Nested Schema Design; Provenance and Source Grounding; Temporal Data Modeling.

Option B preserves the formal failure indicator while making the returned content operationally useful. Anthropic’s tool-use guidance states that when a tool fails, the application should return the error through tool_result content and mark it with is_error: true . Claude can then use that information to retry with corrected input, seek clarification, or explain the limitation. ( https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/bash-tool )

The two example messages identify both the cause and the appropriate recovery path. “Order not found” indicates that repeating the same identifier will not help and proposes an alternative lookup method. “Database timeout” identifies a transient infrastructure condition for which a retry is reasonable. This eliminates blind repetition without removing Claude’s ability to adapt.

Option A can be useful for tightly bounded low-level retries, but it does not solve permanent errors or tell the agent what happened after retries fail. Option C incorrectly disguises a failed operation as successful tool content. Option D moves semantic knowledge into hardcoded orchestration logic, making the system more rigid and duplicating information already known by the tool.

The most reliable tool interface combines the error flag, a stable error type, a retryability indicator, a concise causal explanation, and a recommended recovery action.

Official references/topics: is_error handling, instructive tool results, recovery guidance, resilient MCP tool design.

In the standard Claude tool-use loop, the application executes lookup_order and sends its output back as a tool_result . That result becomes part of the conversation state available to Claude. Claude then evaluates the purchase date, refund policy, customer request, authorization constraints, and available tools before selecting the next action.

Anthropic describes client-tool orchestration as a repeated loop: Claude emits a tool_use request, the application executes it, returns a tool_result , and Claude continues reasoning from the updated conversation. Claude, rather than the tool implementation, selects when and how to invoke the next available tool unless the application has explicitly implemented a fixed workflow. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/how-tool-use-works )

Options B and C describe possible custom orchestration architectures, but neither is stated in the scenario. Option D is inconsistent with adaptive agent behavior because later actions depend on information that did not exist before lookup_order completed. A rigid sequence would not respond appropriately to different purchase dates, eligibility states, or order conditions.

The tool result should return high-signal fields such as purchase date, return-window status, refund eligibility, existing refund status, and stable order identifiers so Claude can make the subsequent decision accurately.

Official references/topics: Tool-result continuation, adaptive agent loops, model-directed tool selection, sequential dependency handling.

Resuming preserves the prior architectural analysis, dependency mapping, and conversation history, avoiding the cost of repeating an hour of valid work. Anthropic states that resuming by session ID restores the agent’s full prior context, including files read, analysis performed, and decisions made. ( https://code.claude.com/docs/en/agent-sdk/sessions )

However, the session represents historical knowledge rather than a repository snapshot. Because three files changed externally, the agent must be told which files are affected and directed to re-read them before relying on earlier conclusions. Anthropic clarifies that sessions persist the conversation, not the filesystem. ( https://code.claude.com/docs/en/agent-sdk/sessions ) Targeted re-analysis updates the stale portion of the agent’s model while retaining the nine unchanged files’ established context.

Option A discards valuable work even though most of the analyzed code remains unchanged. Option C is accurate but inefficient because it reprocesses all twelve files regardless of whether they changed. Option D is unsafe: the agent may continue reasoning from obsolete function signatures, dependencies, or control flows.

The continuation prompt should identify the changed files, summarize the merge’s purpose where known, and request a focused comparison against the earlier understanding. Any architectural conclusions affected by those changes should then be revised explicitly.

Official references/topics: Session Resume; Filesystem Versus Conversation State; Targeted Re-Analysis; Repository Change Awareness.

The implementation approach is unresolved and carries architectural consequences. WebSockets, Server-Sent Events, and polling differ in connection lifecycle, bidirectional communication, proxy compatibility, scaling requirements, deployment topology, reconnection behavior, and operational complexity. Claude should therefore inspect the existing application and infrastructure before modifying code.

Anthropic recommends separating exploration and planning from implementation when the approach is uncertain, the work affects multiple files, or the developer is unfamiliar with the relevant architecture. In plan mode, Claude can read files and analyze the system without making changes, produce a detailed proposal, and allow the developer or team to review the plan before execution. ( https://code.claude.com/docs/en/best-practices )

Option A commits to polling before determining whether its latency and load characteristics meet the requirement. Option B delegates a consequential architectural decision and immediate implementation to a single execution step without a review checkpoint. Option D prematurely selects the most infrastructure-sensitive option and assumes later refactoring will be inexpensive.

Option C creates the correct sequence: examine the frontend and backend architecture, document requirements, compare alternatives, identify infrastructure constraints, obtain approval, and only then implement the selected design with appropriate tests and observability.

Official references/topics: Plan mode, explore–plan–implement workflow, architectural trade-off analysis, review checkpoints.

The venue server must be available to every project contributor, so it belongs at project scope. Claude Code stores project-scoped MCP configurations in the repository-root .mcp.json file, which can be committed to version control and shared with the team.

The experimental playlist server should remain private. Local-scoped MCP servers are stored under the current project’s entry in ~/.claude.json , while user-scoped servers are also stored in ~/.claude.json but load across all projects. Because this server is described as a personal experiment, either private scope is conceptually appropriate; among the listed choices, option B correctly separates shared project configuration from private personal configuration. ( https://code.claude.com/docs/en/mcp )

Option A prevents the team from receiving the venue configuration. Option C reverses the intended visibility. Option D exposes the experimental server configuration to other contributors and may commit machine-specific commands or credentials.

The preferred commands would specify --scope project for the shared venue server and --scope local for an experiment limited to the current repository. Project-scoped servers also require user approval before Claude Code activates configurations received through .mcp.json .

Official references/topics: MCP Installation Scopes; Project Scope; Local Scope; .mcp.json ; ~/.claude.json .

First-contact resolution does not require pretending that every backend operation succeeded. The agent can still resolve the informational portion of the interaction by explaining the charge and confirming eligibility using the successfully retrieved customer and order data. It must then distinguish that verified conclusion from the uncompleted refund transaction.

Anthropic’s tool-error guidance states that Claude should receive the failure information so it can retry, request clarification, or explain the limitation. A tool timeout must therefore be surfaced honestly rather than converted into an unsupported success claim. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/build-a-tool-using-agent?utm_source=chatgpt.com ) Anthropic also emphasizes transparent, simple agent designs and carefully constructed tool interfaces, which support explicit disclosure of tool failure and controlled escalation. ( https://www.anthropic.com/engineering/building-effective-agents )

Option A can create an unbounded or excessively long interaction; retries should be limited and conditioned on retryability. Option B falsely represents an incomplete financial operation as completed. Option D discards the useful work already performed and escalates before providing the customer with the available explanation.

Option C preserves trust, delivers the information already established, clearly states what remains incomplete, and gives the customer a practical next step through bounded retry or human escalation.

Official references/topics: Graceful tool failure, transparent customer communication, bounded retry, human escalation.

The investigation path cannot be reliably predetermined because the responsible files, components, and execution sequence are unknown. The agent should begin with available evidence—such as route definitions, stack traces, logs, or endpoint references—and use each discovery to decide the next search, file read, or diagnostic action.

Anthropic distinguishes predefined workflows from agents that dynamically direct their own processes and tool usage. Agents are appropriate for open-ended problems where the required number and nature of the steps cannot be predicted or encoded as a fixed path. During execution, the agent should obtain ground truth from tool results and adapt its plan based on that environmental feedback. ( https://www.anthropic.com/engineering/building-effective-agents )

Option A requires a comprehensive plan before the agent has inspected the code, so the plan would rest on unsupported assumptions. Option B forces every investigation through the same sequence even when an early discovery makes later steps irrelevant or identifies a different dependency path. Option C assumes the four layers can be investigated independently; tracing an intermittent request failure usually involves dependencies revealed sequentially across layers.

Option D implements an adaptive agent loop: inspect, form a hypothesis, use tools, evaluate the evidence, and generate the next subtask. The workflow should still include stopping conditions, testable hypotheses, and escalation when evidence remains inconclusive.

Official references/topics: Adaptive Agent Loops, Dynamic Task Decomposition, Tool Feedback, Open-Ended Coding Investigations.

Option C is the only approach that guarantees the required terminal condition independently of the model’s behavior. When the agent loop stops, the orchestration layer evaluates the recorded outcome. If neither a successful resolution nor a confirmed human escalation occurred, deterministic application code invokes escalate_to_human using the information accumulated before termination.

The max_turns limit is a host-controlled safety boundary. Once that boundary is reached, the model may no longer have an opportunity to follow a prompt instruction or make another tool call. Therefore, the required fallback cannot depend entirely on Claude deciding to escalate before its remaining turns are exhausted.

Option A escalates based on an arbitrary 80% threshold and may prematurely terminate cases that could have been resolved successfully within the remaining budget. Option B provides additional turn capacity but does not guarantee that the second agent will complete its work or escalate before its own limit is reached. Option D remains probabilistic and cannot operate after an unexpected termination has already occurred.

The orchestration fallback should be idempotent, ensuring that repeated completion checks cannot create duplicate escalation records. It should also include verified customer information, relevant order data, completed actions, failure reasons, and the unresolved request in the handoff payload.

Official references/topics: Agent-loop termination, deterministic fallback orchestration, terminal-state validation, human handoff guarantees.

The failure is caused by an underspecified extraction policy rather than an inadequate JSON structure. “Extract all skills mentioned” does not define whether coordinated phrases should be split, whether inferred capabilities qualify, or what level of specificity constitutes one skill. Few-shot examples can demonstrate all three decisions using concrete inputs and expected outputs.

Anthropic identifies examples as one of the most effective ways to improve output accuracy and consistency because they communicate behavior more precisely than abstract instructions alone. Representative examples can show that “Python and SQL” becomes two entries, that an unstated skill must not be inferred from a job title, and that broad descriptions should not be decomposed into dozens of speculative micro-skills. ( https://docs.anthropic.com/en/docs/about-claude/use-case-guides/ticket-routing )

Option A adds provenance and confidence metadata but does not define the correct extraction granularity. Option C addresses explicitness and splitting, but the arbitrary 10–20 limit can truncate documents containing more than 20 legitimate skills or force padding when fewer than 10 appear. Option D is useful for canonicalization and deduplication, but post-processing cannot reliably remove plausible implied skills or determine how the original phrase should have been interpreted.

The strongest prompt should combine explicit rules with diverse few-shot examples covering normal cases, compound phrases, implied information, duplicates, and unusually long or short skill lists.

Official references/topics: Few-Shot Prompting, Output Consistency, Explicit Extraction Criteria, Representative Examples.

Formatting is deterministic and should be enforced by deterministic tooling rather than stronger natural-language instructions. A PostToolUse hook executes after a successful tool operation. Matching Edit|Write restricts the hook to file modifications, allowing the edited file path to be passed directly to Prettier.

Anthropic provides this exact pattern in its official hooks guidance: configure a PostToolUse event with an Edit|Write matcher and run Prettier against the modified file. This ensures formatting occurs automatically after every relevant edit instead of depending on Claude remembering to execute a formatter. ( https://code.claude.com/docs/en/hooks-guide )

Option A still relies on instruction-following and unnecessarily loads procedural material. Option B asks another probabilistic model evaluation to determine whether formatting is correct, even though Prettier can enforce the result directly. A Stop hook also runs later than necessary. Option C improves contextual relevance but does not guarantee compliance; path-scoped rules remain instructions rather than enforcement controls.

The hook should be stored in project settings so the workflow is shared by the team. The formatter’s exit status should also be monitored so configuration or syntax failures are visible instead of silently ignored.

Official references/topics: Claude Code Hooks; PostToolUse; Edit|Write Matchers; Deterministic Formatting Enforcement.

The root cause is an incomplete tool contract. Claude sees that process_refund requires an order_id , but the tool description does not explain the parameter’s trusted source or the prerequisite lookup sequence. Option A makes the dependency explicit and prohibits fabricated values.

Anthropic states that tool descriptions should explain what a tool does, when it should be used, how it behaves, and any important limitations. Its prompting guidance also states that dependent tool calls must be executed sequentially and that Claude must never use placeholders or guess missing tool parameters. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools )

Option B merely forces some tool use; it does not force the correct tool or prevent a fabricated identifier. Option C is an essential defense-in-depth control, but it detects the invalid ID after the model has already made the faulty call. It does not correct the selection logic that caused the fabrication. Option D works only when the customer actually provides an identifier and introduces an unnecessary preprocessing dependency.

The process_refund schema should describe order_id as a verified identifier returned by lookup_order , and the tool description should state that the tool is unavailable until the corresponding order has been retrieved and eligibility established.

Official references/topics: Tool descriptions, prerequisite tool calls, parameter provenance, sequential tool orchestration.

The task is open-ended because neither the critical modules nor the required testing sequence is known in advance. The agent should first use lightweight discovery tools to map the repository, locate existing tests, identify central modules, and determine which components have high fan-in, business significance, complex branching, or extensive external dependencies. It can then produce an initial risk-based testing plan and refine it as new dependency information appears.

Anthropic distinguishes predefined workflows from agents that dynamically control their processes and tool usage. Agents are appropriate when the required steps cannot be reliably hardcoded and must adapt to environmental evidence. During execution, they should obtain ground truth through tool results and use that feedback to determine subsequent actions. ( https://www.anthropic.com/research/building-effective-agents ) Anthropic also identifies orchestrator-worker designs as suitable for complex coding and search tasks where the necessary subtasks depend on what the investigation reveals. ( https://www.anthropic.com/research/building-effective-agents )

Option A assigns effort using directory boundaries rather than risk. Option C exhausts context before delivering value. Option D uses alphabetical order, which has no relationship to impact or coverage priority.

Option B establishes an evidence-driven decomposition: discover, prioritize, test high-impact paths, measure results, and revise the plan as dependencies and uncovered risks emerge.

Official references/topics: Dynamic Task Decomposition; Adaptive Agent Loops; Orchestrator-Workers; Risk-Based Test Planning.