Anthropic Claude Certified Architect - Foundations CCAR-F Exam Questions

Page: 1 / 14
Total 152 questions

Want more questions? Get Premium Access.
()

Question 1

You are building a structured data extraction system using Claude. The system extracts information from unstructured documents, validates the output using JavaScript Object Notation (JSON) schemas, and maintains high accuracy. It must handle edge cases gracefully and integrate with downstream systems.

The system routes documents with extraction confidence below 85% to human review. A quarterly audit reveals that 12% of high-confidence extractions (85%) also contain errors---cases where the model finds plausible-but-incorrect values. Error sources vary: comparison tables showing competitor specs, appendices referencing different product variants, and ambiguous phrasing the model misinterprets. You need a sustainable strategy to catch these high-confidence errors and measure whether improvements reduce the error rate over time.

What approach is most effective?

AAdd a verification pass that re-extracts from each high-confidence document, flagging cases where the two extraction attempts produce different results.

BImplement heuristic rules that flag documents containing comparison tables or appendices for review regardless of confidence score.

CLower the confidence threshold from 85% to 70%, routing a larger volume of extractions to human review.

DImplement stratified random sampling reviewing a fixed percentage of high-confidence extractions weekly, enabling error rate measurement and novel pattern detection.

Answer : D

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.

Question 2

Production monitoring shows that follow-up queries such as ''summarize what we learned about market trends'' consistently take more than 40 seconds. Investigation reveals that the coordinator spawns the synthesis subagent for every summarization request, passing more than 80,000 tokens of accumulated findings. The coordinator already has these findings in its context from orchestrating the research. What is the most effective way to improve response time for these follow-up summaries?

APregenerate and cache summaries at multiple levels of detail whenever new findings accumulate.

BEnable prompt caching for the synthesis subagent to reduce the overhead of repeatedly transferring the same research findings.

CHave the coordinator answer straightforward summarization requests directly from its existing context, reserving subagent invocation for complex analysis.

DSpawn the synthesis subagent with reduced context and allow it to request specific findings from the coordinator on demand.

Answer : C

Option C avoids an unnecessary agent boundary. The coordinator already possesses the accumulated findings and can perform a straightforward summary without serializing, transferring, and reprocessing more than 80,000 tokens in another context window. Subagents should be reserved for work that requires isolated context, specialized instructions, separate tools, or an independent analytical process.

Anthropic's current prompting guidance advises using subagents for independent workstreams and parallel or context-isolated tasks, while handling simpler tasks directly. Anthropic also notes that excessive subagent use creates unnecessary cost and latency.

Option A generates multiple summaries speculatively, consuming resources even if they are never requested and creating cache-invalidation complexity whenever findings change. Option B may reduce repeated input-token cost, but it does not eliminate subagent startup, message processing, or the unnecessary orchestration round trip. Option D introduces an iterative request protocol that will likely increase latency further. Direct coordinator summarization uses information already available in active context and therefore provides the smallest architectural change, lowest token-transfer overhead, and fastest response while preserving subagent synthesis for genuinely complex comparative or cross-source analysis.

================

Question 3

You are building a structured data extraction system using Claude. The system extracts information from unstructured documents, validates the output using JSON schemas, and maintains high accuracy. It must handle edge cases gracefully and integrate with downstream systems.

After implementing tool use with strict schema definitions, JSON syntax errors are eliminated, but 5% of extractions still contain empty arrays or null values for required fields such as citations and methodology. Spot-checking reveals that the source documents contain this information, but in varied formats---inline citations versus bibliographies, and methodology sections versus details embedded in introductions.

What is the most effective way to address these failures?

AImplement retry logic that resends requests when validation detects empty required fields.

BAdd few-shot examples demonstrating extractions from documents with varied structures, showing how to identify citations in different formats and locate methodology details across section types.

CBuild a regex-based post-processing layer that scans source documents for citation patterns and methodology keywords, populating empty fields when the model fails to extract them.

DModify the schema to make citations and methodology optional, and flag incomplete records for manual review instead of failing validation.

Answer : B

Option B targets the remaining failure mode: semantic recognition across heterogeneous document structures. Strict schemas eliminate malformed JSON and can guarantee that tool inputs conform to declared types, but they cannot force Claude to locate evidence that appears under unfamiliar headings or in atypical sections. Anthropic's prompting guidance says that a few relevant, diverse, structured examples are among the most reliable ways to improve accuracy and consistency. Examples should therefore show inline citations, reference lists, numbered bibliographies, methodology sections, and methods embedded in introductions, each paired with the correct extracted structure. This teaches the intended evidence-location and granularity rules rather than merely repeating the same request. Option A retries an unchanged prompt and can reproduce the same omission. Option C introduces brittle regex rules that may miss nonstandard citations and mistake keyword mentions for methodology content. Option D suppresses validation failures by weakening the contract, but it does not improve extraction and would convert recoverable omissions into incomplete records. The examples should be drawn from real failure cases, evaluated on a held-out set, and expanded when monitoring reveals new layouts. Schema constraints and few-shot coverage solve different layers of reliability and should be used together.

================

Question 4

You are using Claude Code to accelerate software development. Your team uses it for code generation, refactoring, debugging, and documentation. You need to integrate it into your development workflow with custom slash commands, CLAUDE.md configurations, and understand when to use plan mode vs direct execution.

You're implementing a new payment processing module that must follow your project's established patterns for database transactions, error handling, and audit logging. You've identified three existing modules that exemplify these patterns: db_utils.py, error_handlers.py, and audit_logger.py. This is a one-off integration task---these patterns are well-documented in your team wiki and don't need additional project-level documentation.

What's the most effective approach?

AUse @ references to include the three modules directly in your prompt, giving Claude concrete code examples of the patterns to follow.

BAdd documentation of each pattern to your CLAUDE.md file, establishing them as project conventions that Claude will apply automatically.

CDescribe the patterns from the three modules in natural language in your prompt, explaining the transaction handling approach, error format, and logging conventions Claude should follow.

DAsk Claude to explore your codebase to find and understand the transaction, error handling, and logging patterns before generating the new module.

Answer : A

Direct @ references provide Claude with the exact implementations it must imitate. Anthropic documents that referencing a file with @ includes the full file content in the conversation, and multiple files can be referenced in one message. This gives Claude immediate access to the real transaction boundaries, exception structures, audit fields, naming conventions, and helper APIs used by the project. (https://code.claude.com/docs/en/common-workflows)

Option B is inappropriate because the task is explicitly one-off and the conventions are already documented elsewhere. CLAUDE.md is loaded into every session and should contain concise information that broadly applies to the project. Adding detailed implementation material for a single integration would consume context unnecessarily. Anthropic recommends moving occasional procedures to skills and keeping CLAUDE.md limited to persistent, widely applicable guidance. (https://code.claude.com/docs/en/memory)

Option C loses precision because a natural-language summary may omit subtle but important code behavior. Option D asks Claude to rediscover files that have already been identified, increasing exploration time and context usage.

The most effective prompt should reference all three modules, identify which pattern each demonstrates, specify the new module's required behavior, and request focused tests proving that the established conventions were followed.

Official references/topics: @ file references, rich prompt context, CLAUDE.md scope, pattern-based implementation.

Question 5

Your extraction pipeline validates outputs against JSON schemas, but you need to implement human review given limited reviewer capacity (they can handle approximately 5% of total extraction volume).

What's the most effective basis for selecting which extractions to route for human review?

ARoute extractions where the model indicates low confidence or where source documents contain ambiguous or contradictory information.

BRoute extractions containing specific high-priority entity types (e.g., financial figures, dates) for human review, regardless of extraction confidence.

CRoute extractions for review only when downstream systems report data quality issues or processing failures.

DRandomly sample 5% of extractions for review.

Answer : A

Limited review capacity should be concentrated on records with the highest probability of semantic error. Schema validation confirms that the response has the correct structure and data types; it does not establish that the extracted values are accurate. Ambiguous wording, contradictory passages, missing evidence, and model-reported uncertainty are direct indicators that an extraction requires human judgment.

Anthropic's reliability guidance recommends permitting Claude to express uncertainty, grounding factual outputs in source material, and validating critical information because hallucination-reduction methods do not eliminate errors completely. These principles support routing uncertain or evidentially conflicted records to reviewers rather than treating syntactically valid output as automatically trustworthy. (https://docs.anthropic.com/en/docs/test-and-evaluate/strengthen-guardrails/reduce-hallucinations)

Option B may waste reviewer capacity on clear, well-supported values while overlooking ambiguous errors in other fields. Option C is reactive: downstream acceptance does not guarantee semantic correctness, and silent errors may never produce processing failures. Option D provides an unbiased estimate of overall quality and should be retained as a secondary audit mechanism, but random selection is not the most efficient way to intercept risky records when only 5% can be reviewed.

In production, model confidence should not be treated as a calibrated probability by itself. It should be combined with objective signals such as contradictory source spans, missing citations, OCR quality, validation warnings, document type, and business impact.

Official references/topics: Human-in-the-Loop Review, Uncertainty Handling, Source Grounding, Risk-Based Escalation.

Question 6

During initial testing of the automated review pipeline, you notice that reviews of large pull requests containing more than 50 changed files sometimes take over 20 minutes and cost $8--$12 per run because of extensive agentic loops---Claude reads files, runs analysis tools, and iterates many times. Your team needs each invocation to abort after reaching either a fixed iteration count or a fixed dollar amount. Both limits must be enforced by Claude Code itself rather than by the surrounding job runner. Which configuration change directly enforces both per-invocation limits?

AAdd --max-turns 10 --max-budget-usd 2.00 to the claude -p invocation to cap agentic turns and expenditure.

BSet --permission-mode dontAsk to automatically deny tool-permission requests that are not in the explicitly allowed set.

CSet timeout-minutes: 5 on the GitHub Actions step and monitor per-run costs through the Anthropic Console usage dashboard.

DUse the --model flag to select a smaller, less expensive model so that every iteration uses fewer tokens and costs less.

Answer : A

Option A is the only configuration that establishes both required limits inside Claude Code. The official CLI reference defines --max-turns as the maximum number of agentic turns permitted in print mode; Claude Code exits with an error when that limit is reached. It defines --max-budget-usd as the maximum dollar expenditure on API calls before execution stops, including applicable subagent expenditure.

These controls address different failure dimensions. The turn limit prevents an investigation from continuing through excessive read-search-analyze cycles, while the budget limit stops an invocation whose expensive turns consume the monetary allowance before reaching the turn ceiling. Supplying both therefore creates an effective per-run boundary.

Option B controls how permission requests are handled; it does not limit the number of already permitted tool calls or API expenditure. Option C applies an external wall-clock timeout and merely observes cost, violating the requirement that Claude Code itself enforce both limits. Option D lowers expected cost per turn but creates no hard ceiling: the agent can still perform many iterations and exceed the intended budget. A cheaper model also does not guarantee that the review will terminate within a predictable number of turns.

================

Question 7

You need to add a date validation check ensuring event dates are in the future. This requires adding a conditional statement to one existing function in a single file.

What is the most appropriate approach?

AUse direct execution to make the change.

BStart with extended thinking mode enabled to ensure thorough reasoning about the validation logic.

CEnter plan mode first to create a detailed implementation strategy before making the change.

DEnter plan mode to analyze how the validation might impact other parts of the reservation flow.

Answer : A

This change is narrow, localized, and already defined: add one conditional validation check to an existing function in a single file. A separate planning phase would introduce process overhead without resolving meaningful architectural uncertainty. Direct execution allows Claude to read the function, implement the condition, and run the relevant focused tests.

Anthropic explicitly states that plan mode adds overhead and should generally be skipped when the scope is clear and the fix is small. Planning is most valuable when the approach is uncertain, multiple files are affected, or the code is unfamiliar. Anthropic's practical rule is that when the required diff can be described in one sentence, direct implementation is appropriate. (https://code.claude.com/docs/en/best-practices)

Option B allocates unnecessary reasoning effort to straightforward validation logic. Options C and D exaggerate the complexity of a single-function change. Broader impact analysis would be justified only if the requirement altered reservation semantics, time-zone rules, persistence behavior, or public interfaces---none of which is stated.

The implementation should still include verification. Claude should add or update tests for a future date, the current date, and a past date, then run the narrowest relevant test command. Direct execution does not mean unverified execution.

Official references/topics: Direct Execution; Plan-Mode Selection; Small Scoped Changes; Focused Verification.