CCAR-F Claude Certified Architect – Foundations Questions and Answers

The pipeline must preserve source evidence while making inconsistencies explicit. Option D records the amount stated on the invoice separately from the total derived from extracted line items. A mismatch then becomes a machine-detectable validation condition rather than an invisible extraction defect.

This approach is superior because it does not silently overwrite source data or ask another model to guess which value is correct. Anthropic’s evaluation guidance recommends automated, code-based grading whenever the criterion can be expressed deterministically. Arithmetic reconciliation is precisely such a criterion. ( https://docs.anthropic.com/en/docs/build-with-claude/develop-tests ) In production, the summation should preferably be calculated by application code using normalized decimal values, even though the option describes the model populating calculated_total . The essential design principle remains the same: preserve stated_total , compute an independent total, compare them, and route discrepancies for adjudication.

Option A might improve behavior but cannot resolve genuine OCR corruption and could encourage the model to modify extracted values merely to create mathematical consistency. Option B introduces a second probabilistic judgment without new evidence. Option C is unacceptable for accounting data because it fabricates adjusted amounts and destroys fidelity to the invoice.

The schema should therefore expose both values and attach a validation status or review reason when they differ.

Official references/topics: Deterministic Validation; Human-in-the-Loop Review; Structured Output Design; Source-Fidelity Controls.

A schema-defined tool provides a structured interface between Claude and the application. The tool’s input_schema can declare required properties, nested work-experience and education objects, arrays of skills, and exact data types. Claude then supplies the extracted resume information as tool-call arguments, which the application can read directly from the tool_use response.

Anthropic’s tool documentation specifies that a custom tool definition includes a JSON Schema object describing its expected parameters. Current strict tool use can additionally enforce that generated tool arguments match the declared schema exactly. This removes the need to locate JSON inside free-form text or depend on post-generation repair. ( https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use )

Option A is fragile because regular expressions do not provide a robust parser for arbitrary nested JSON and cannot correct missing properties or incorrect types. Option B improves formatting behavior but remains probabilistic. Option C doubles latency and creates two opportunities for information loss: first during extraction and again during reformatting.

In a production design, fields that may genuinely be absent from a resume should be optional or nullable rather than forcing invented values. The tool schema should also use strict: true where supported. Among the available choices, D provides the strongest structural guarantee and the cleanest downstream integration.

Official references/topics: Tool Use Responses, Input Schemas, Strict Tool Use, Nested Structured Extraction.

Option B removes the ambiguity from the tool interface itself. The agent no longer needs to choose between separate functions that represent closely related business operations. Instead, a single compensation tool exposes an explicit action parameter, while the existing order lookup tool can optionally return delivery-tracking information through a clearly defined flag.

Anthropic’s tool-design guidance recommends consolidating related operations into fewer, more capable tools when separate functions create unnecessary semantic overlap. Claude selects tools primarily from their names, descriptions, schemas, and the current task. When multiple tools appear capable of satisfying the same request, selection accuracy declines because the agent must infer distinctions that should have been made explicit in the interface design.

Option A adds routing complexity but leaves overlapping financial operations available within the same sub-agent. Option C reduces the number of tools loaded initially, but it does not eliminate the semantic duplication between compensation operations or overlapping lookup functions. Option D may improve behavior through examples, but it compensates for a poorly designed tool surface rather than correcting the root cause.

The consolidated schemas should use enums for supported actions, clearly define when each action applies, and document the returned fields. This creates a smaller and more deterministic agent-computer interface.

Official references/topics: Tool consolidation, semantic tool boundaries, action parameters, MCP tool-selection accuracy.

MCP prompts are exposed as user-invoked commands rather than autonomous tools or permanently loaded system instructions. Claude Code dynamically discovers prompts from connected MCP servers and displays them in the command list using the naming convention /mcp__servername__promptname .

Arguments are supplied as space-separated values after the command. When executed, the MCP server resolves the prompt and its returned content is injected into the active conversation. Anthropic’s official documentation provides examples such as /mcp__github__list_prs and /mcp__jira__create_issue "Bug in login flow" high . ( https://code.claude.com/docs/en/mcp )

Option A would consume context continuously and incorrectly treat optional workflow templates as mandatory system instructions. Option B confuses MCP prompts with MCP tools: tools are model-callable operations, while prompts are reusable prompt templates invoked as commands. Option C describes MCP resources, which can be referenced and attached but are a distinct MCP capability.

For the stated server, the team could invoke commands such as /mcp__devops__deploy_checklist or /mcp__devops__incident_response service-name . The exact server segment is derived from the configured server name, with normalization applied where necessary.

Official references/topics: MCP Prompts; Dynamic Prompt Discovery; MCP Slash-Command Naming; Prompt Arguments.

A mid-process escalation should transfer the decision-ready state accumulated by the agent. The human reviewer needs the verified customer identity, relevant order information, the promotional-pricing discrepancy, the reason approval is required, and any actions already attempted. Option B preserves this information in a concise, structured handoff while avoiding unnecessary repetition of the complete raw transcript.

Anthropic’s tool-design guidance recommends returning high-signal information and stable identifiers containing only what Claude or the next workflow participant needs to determine the next action. Anthropic’s context-engineering guidance similarly advocates structured notes that preserve critical state and dependencies without retaining every redundant tool result. A structured escalation payload applies both principles and reduces handling time for the manager. ( https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools )

Option A discards the investigation already completed. Option C violates the agent’s authorization boundary and risks an impermissible financial action. Option D provides auditability, but a reference ID alone forces the human to reconstruct the case from an excessively broad transcript. Human control must remain meaningful when an agent encounters a decision outside its authority; the agent should pause and hand the decision back with sufficient supporting context. ( https://www.anthropic.com/research/trustworthy-agents )

Official references/topics: Structured agent handoffs, high-signal tool results, human-control boundaries, persistent structured state.

Stratified random sampling provides both an ongoing quality-control mechanism and an unbiased measurement framework. By reviewing a fixed proportion of high-confidence outputs across meaningful strata—such as document type, field, source format, and business risk—the organization can estimate the residual error rate, compare performance across releases, and discover failure patterns that were not anticipated when existing rules were designed.

Anthropic recommends measurable success criteria and evaluations that mirror the real-world task distribution, including edge cases. Evaluation volume and repeatability are important because improvements must be demonstrated empirically rather than inferred from isolated examples. ( https://docs.anthropic.com/en/docs/build-with-claude/develop-tests ) A weekly sampling program creates a stable benchmark and allows confidence intervals, trend analysis, regression detection, and error-taxonomy updates.

Option A detects only disagreements between stochastic extractions. Two attempts may produce the same plausible but incorrect answer, so agreement is not equivalent to factual correctness. Option B addresses known patterns but will miss new failure modes and may generate excessive false positives. Option C actually lowers the review threshold in the wrong direction: documents between 70% and 85% would be treated as automated rather than reviewed if the routing rule remains “below threshold,” and changing thresholds alone does not measure high-confidence error prevalence.

Official references/topics: Evaluation Design; Representative Test Distributions; Continuous Reliability Measurement; Human-in-the-Loop Sampling.

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.

Forking the existing analysis session creates independent continuations that inherit the accumulated conversation context. Each branch begins with the same understanding of the service module, request flow, source files, and error-handling patterns, but subsequent work on one testing strategy does not alter the other branch or the original session.

Anthropic’s Agent SDK documentation states that sessions can be resumed with their full context and forked to explore different approaches. In the SDK, enabling fork_session while resuming causes the continuation to receive a new session identifier rather than modifying the original session. ( https://docs.anthropic.com/en/docs/claude-code/sdk?utm_source=chatgpt.com )

Option B wastes time, tokens, and tool calls by requiring both new sessions to rebuild the same 23-file analysis. Option C mixes two experimental implementations into one conversation, increasing the risk that assumptions, edits, or conclusions from the first strategy influence the second. Option D preserves only a manually selected summary, which may omit details contained in the full session history.

The appropriate design is to create one fork for the end-to-end strategy and another fork for the snapshot strategy. The original analysis remains a stable parent, while each child session develops and evaluates its approach independently.

Official references/topics: Agent SDK Sessions, Session Forking, Context Preservation, Alternative-Approach Evaluation.

Project skills are stored at .claude/skills/ < skill-name > /SKILL.md . The directory name becomes the invocable command name, so .claude/skills/migrate-component/SKILL.md creates /migrate-component . Anthropic distinguishes project skills from personal skills: project skills apply only to the repository, while skills under ~/.claude/skills/ apply to one user across all projects. ( https://code.claude.com/docs/en/skills )

Committing the project skill to version control ensures that every developer receives the same workflow and that changes are reviewed, versioned, and synchronized with the codebase. Anthropic’s .claude directory guidance states that project configuration should be committed when it is intended to be shared with the team, whereas files under ~/.claude are personal. ( https://code.claude.com/docs/en/claude-directory )

Option A requires manual duplication across developer machines and allows versions to diverge. Option B loads the migration procedure into every conversation even when no migration is occurring; Anthropic recommends skills for reusable checklists and multi-step procedures because their bodies load only when used. Option C describes no valid mechanism for defining a skill’s content in settings.json .

Option D provides the correct scope, command name, on-demand loading behavior, and team distribution model.

Official references/topics: Project skills, SKILL.md structure, command invocation, version-controlled team configuration.

The Claude Messages API is stateless. Each API request must include the conversation history that Claude requires for the current response. If the application sends only the customer’s third verification answer, Claude does not automatically retrieve the earlier turns containing the customer’s name and previous answers. From the model’s perspective, that information is absent.

Anthropic’s Messages API documentation states that applications must send the full conversational history to build a multi-turn interaction. The correct implementation appends each user message and assistant response to the messages array and resends the accumulated sequence on every subsequent request. ( https://platform.claude.com/docs/en/build-with-claude/working-with-messages )

Option A cannot restore information that was omitted from the request. Instructions to “remember” do not create server-side conversational state. Option C describes application-specific behavior for which the scenario provides no evidence. Option D is factually incorrect: Claude does not have a default two-turn retention limit. Its effective conversational awareness depends on the messages provided and the model’s context window.

For a verification workflow, the application should also persist structured verification state separately from prose history. That state may include completed checks, pending checks, attempt counts, and a verified customer identifier. This improves reliability while the conversational transcript preserves the natural interaction.

Official references/topics: Stateless Messages API, multi-turn history construction, structured workflow state, conversational continuity.

The search must first establish the function’s complete naming surface. Reading the core definition and every wrapper or re-export reveals aliases such as computeOrderTax , names introduced through intermediate modules, and potentially different import paths. Once those names are known, the agent can search the entire codebase for each exposed identifier and inspect the resulting call sites.

Claude Code’s Grep tool searches patterns inside file contents, whereas Read provides the surrounding implementation needed to determine whether a wrapper delegates to, renames, or conditionally invokes the original function. These tools are complementary: Read establishes semantic identity; Grep provides broad reference discovery. ( https://code.claude.com/docs/en/tools-reference?utm_source=chatgpt.com )

Option B misses every caller using a wrapper alias. Option A may find importing files, but import-level discovery is indirect and can miss re-exports, namespace imports, dependency injection, or calls made through a locally renamed symbol. It also requires unnecessary manual inspection of every consumer of the module. Option D relies on documentation, which may be incomplete or stale and cannot prove that all executable references have been found.

Before removal, the agent should also inspect tests, dynamic registrations, configuration-driven references, and generated code where relevant. The defining requirement is to map the alias chain first and then search all discovered public names.

Official references/topics: Read and Grep Tool Behavior; Symbol and Alias Discovery; Codebase Reference Tracing.

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.

The checklist is a reusable, task-specific procedure that should load only when a pull-request review is being performed. A /review command provides an explicit invocation mechanism, prevents repeated copy-and-paste, and keeps the checklist out of unrelated coding, debugging, and documentation sessions.

In current Claude Code terminology, custom commands have been consolidated into skills. A .claude/skills/review/SKILL.md file creates a /review command, while the legacy .claude/commands/review.md format remains supported. Anthropic recommends skills when users repeatedly supply the same checklist or multi-step procedure; unlike CLAUDE.md content, the skill body is loaded only when invoked or determined relevant. ( https://code.claude.com/docs/en/skills )

Option B introduces an isolated agent context when the requirement is primarily to inject a repeatable review procedure. A subagent could be useful for independent verification, but it is not necessary merely to avoid repasting the checklist. Option C bloats every session with instructions that apply only to code review. Option D controls editing permissions and planning behavior; it does not encode review criteria.

The review skill can also pre-authorize read-only tools and accept a pull-request identifier or branch as an argument.

Official references/topics: Claude Code Skills; Custom Slash Commands; On-Demand Instructions; Reusable Review Workflows.

The most reliable architecture separates semantic interpretation from deterministic normalization. Claude is well suited to identifying that “$12” and “12.00” represent prices, or that a leaf icon represents a dietary classification. However, canonical conversion—removing currency symbols, converting values to decimal types, mapping icons to controlled labels, and enforcing locale-specific rules—is more predictably performed in application code.

Structured Outputs guarantee that Claude returns valid JSON matching the supplied schema, but that guarantee concerns structural conformance. It does not by itself guarantee that every semantically equivalent source representation will be normalized identically. Anthropic’s evaluation guidance identifies code-based checks as the fastest, most reliable, and most scalable mechanism for rule-based validation. ( https://platform.claude.com/docs/en/build-with-claude/structured-outputs )

Option D therefore minimizes model responsibility: Claude extracts the evidence as represented, and deterministic post-processing converts it into the canonical downstream format. This also makes normalization rules independently testable, version-controlled, and auditable.

Option A increases latency and cost without solving normalization. Option B improves output structure, but prompt-based normalization can still vary across ambiguous formats. Option C introduces unnecessary stochasticity and majority-vote logic where explicit parsing rules are available. The downstream contract should remain stable, but format conversion should be implemented using deterministic transformations rather than repeated probabilistic inference.

Official references/topics: Structured Outputs—schema compliance; Evaluation Design—code-based validation; Reliable extraction pipelines.

Claude selects tools principally from their names, descriptions, parameter schemas, and the task context. The current description—“Analyzes dependency graph”—does not explain why the MCP tool is superior to a familiar text search. It omits the tool’s scope, the circumstances in which it should be selected, and the structured information it returns.

Anthropic identifies detailed descriptions as the most important factor in tool-use performance. A strong description should state what the tool does, when it should and should not be used, what its parameters mean, and any limitations. Anthropic recommends several sentences for complex tools rather than a short generic label. ( https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use ) The MCP connector guidance likewise states that Claude selects among available tools using their names and descriptions and that clear, specific descriptions improve selection accuracy. ( https://docs.anthropic.com/en/docs/agents-and-tools/mcp-connector )

Option B makes the functional distinction explicit: Grep locates textual import statements, whereas analyze_dependencies constructs a semantic graph containing direct and transitive dependencies, cycles, and potentially unresolved references. Option A is a brittle global override. Option C removes a generally useful tool. Option D increases the number of tools and selection ambiguity, contrary to Anthropic’s recommendation to consolidate related operations where practical.

Official references/topics: MCP Tool Discovery; Tool Descriptions; Tool Selection Accuracy; Tool-Surface Design.