Anthropic CCAR-F Exam Questions (Updated 2026) 100% Real Question Answers [Q13-Q35]

Rate this post

Anthropic CCAR-F Exam Questions (Updated 2026) 100% Real Question Answers

Pass Anthropic CCAR-F Exam Quickly With PrepAwayPDF

Anthropic CCAR-F Exam Syllabus Topics:

Section	Weight	Objectives
Topic 1: Agentic Architecture & Orchestration	27%	– Error recovery, guardrails and safety patterns – Multi-agent patterns: coordinator-subagent and hub-and-spoke – Task decomposition and dynamic subagent selection – Session state management and workflow enforcement – Agentic loop design and stop_reason handling
Topic 2: Claude Code Configuration & Workflows	20%	– CLAUDE.md hierarchy, precedence and @import rules – Path-specific rules and .claude/rules/ configuration – Hooks vs advisory instructions – Custom slash commands and plan mode vs direct execution – CI/CD integration and non-interactive mode parameters
Topic 3: Context Management & Reliability	15%	– Token budget management and cost control – Idempotency, consistency and failure resilience – Context window optimization and prioritization – Context pruning and summarization strategies
Topic 4: Tool Design & MCP Integration	18%	– Error handling and tool response formatting – MCP tool, resource and prompt implementation – Tool distribution and permission controls – Model Context Protocol (MCP) architecture and JSON-RPC 2.0 – Tool schema design and interface boundaries
Topic 5: Prompt Engineering & Structured Output	20%	– Validation, parsing and retry loop strategies – JSON schema design and structured output enforcement – System prompt design and persona alignment – Explicit criteria definition and few-shot prompting

NO.13 You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate repetitive tasks. It uses the built-in tools (Read, Write, Bash, Grep, Glob) and integrates with Model Context Protocol (MCP) servers.
An engineer asks your agent to identify untested code paths in a legacy payment processing module spanning
45 files. After reading the first 8 source files, the agent’s responses are becoming noticeably less accurate-it’ s forgetting previously discussed code patterns and hasn’t yet located all test files or traced critical payment flows.
What’s the most effective approach to complete this investigation?

Spawn subagents to investigate specific questions (e.g., “find all test files for payment processing,”
“trace refund flow dependencies”) while the main agent coordinates findings and preserves high-level understanding.

Clear context with /clear , then selectively re-read only the most critical files discovered so far, writing key findings to a scratchpad file that persists between context resets.

Switch to using Grep to search for specific function names instead of reading full files, reducing the content loaded into context for remaining exploration.

Document all current findings in a summary report, clear context completely, then use that report as the sole reference for continuing the investigation.

NO.14 You are building a customer support resolution agent using the Claude Agent SDK. The agent handles high- ambiguity requests like returns, billing disputes, and account issues. It has access to your backend systems through custom Model Context Protocol (MCP) tools ( get_customer , lookup_order , process_refund , escalate_to_human ). Your target is 80%+ first-contact resolution while knowing when to escalate.
A customer contacts the agent about a warranty claim on a power drill. Resolving this requires multiple sequential tool calls: get_customer to look up their account, lookup_order to find the purchase details, and then either process_refund or escalate_to_human depending on warranty eligibility. You’re implementing the agentic loop that orchestrates these steps using the Claude API.
What is the primary mechanism your application uses to determine whether to continue the loop or stop?

You check whether Claude’s response contains a text content block-if text is present, the agent has produced its final answer and the loop should exit.

You manually set the tool_choice parameter to “none” after the final expected tool call to force Claude to stop requesting tools.

You check the stop_reason field in each API response-the loop continues while it equals “tool_use” and exits when it changes to “end_turn” or another terminal value.

You track the number of tool calls made and exit the loop once a preconfigured maximum is reached.

NO.15 Your automated review generates many findings per pull request, but developer feedback shows that roughly half are dismissed as “not worth addressing.” Analysis reveals that dismissed findings are often technically accurate but involve minor style preferences or patterns that are acceptable in your codebase. Before adding infrastructure complexity, what prompt-design change could most effectively reduce dismissals while maintaining the detection of genuine issues?

Add explicit criteria defining which issues to report, such as bugs and security defects, and which issues to skip, such as minor style preferences and accepted local patterns.

Implement a secondary classification model that filters Claude’s findings according to predicted developer acceptance.

Ask Claude to rate every finding’s confidence from 1 to 10 and include only findings rated 8 or higher.

Append instructions telling Claude to “only report findings you are highly confident are genuine problems.”

NO.16 You are integrating Claude Code into your Continuous Integration/Continuous Deployment (CI/CD) pipeline.
The system runs automated code reviews, generates test cases, and provides feedback on pull requests. You need to design prompts that provide actionable feedback and minimize false positives.
Your pipeline reviews every pull request using a single API call with a static prompt containing the diff and the full text of each changed file. Unchanged files are not included. Developers report that reviews consistently miss cross-file bugs-for example, a pull request renames a function’s parameters, but the review does not identify callers in unchanged files that still use the old argument order.
Evaluation shows that cross-file bugs account for 35% of production incidents originating from reviewed pull requests.
What is the most effective change to the review design?

Build a static dependency graph and include every file located within two dependency hops of a changed file.

Add instructions asking the model to list external references and reason step by step about how each change could affect unseen callers.

Redesign the review as a turn-limited agentic task that can read files and search the repository, following references to verify cross-file findings.

Run separate review passes for each changed file with its direct dependants, and then aggregate and deduplicate the findings through a final consolidation pass.

NO.17 You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate repetitive tasks. It uses the built-in tools (Read, Write, Bash, Grep, Glob) and integrates with Model Context Protocol (MCP) servers.
Your code review assistant needs to analyze pull requests and provide feedback on three aspects: code style compliance, potential security issues, and documentation completeness. Each aspect requires reading files, running analysis tools, and generating a report section. The review process follows the same three-step workflow for every PR.
Which task decomposition pattern is most appropriate for this workflow?

Single comprehensive prompt-include all three instructions in one prompt and let the model handle all three aspects simultaneously.

Orchestrator-workers-have a central LLM analyze each PR to dynamically determine which checks are needed, then delegate to specialized worker LLMs for each identified subtask.

Prompt chaining-break the review into sequential steps where each aspect (style, security, documentation) is analyzed separately, with outputs combined in a final synthesis step.

Routing-classify each PR by type (feature, bugfix, refactor) first, then route to different review prompts optimized for that category.

NO.18 You are integrating Claude Code into your Continuous Integration/Continuous Deployment (CI/CD) pipeline.
The system runs automated code reviews, generates test cases, and provides feedback on pull requests. You need to design prompts that provide actionable feedback and minimize false positives.
Your automated review calls the Claude API for each pull request, using tool_use with a report_findings tool that returns a JSON array of finding objects. Each object contains file_path, line_number, severity, category, and description. During testing on a large pull request touching more than 30 files, the response reaches the max_tokens limit and is truncated in the middle of the JSON, causing your pipeline’s parser to fail.
What is the most effective way to handle this?

Split the review into multiple API calls that each analyze a subset of the changed files, and then merge the resulting findings arrays.

Increase max_tokens to the model’s maximum and instruct Claude to keep each finding description under 50 words.

Switch from tool_use to prompting Claude to return findings as a Markdown list.

Add retry logic that detects truncated JSON and resends the request with instructions to report only critical and high-severity findings.

NO.19 After the web-search agent finds 25 sources containing 120,000 tokens of raw content, the document-analysis agent extracts 15,000 tokens of key insights, and the synthesis agent produces a coherent 3,000-token narrative draft, the coordinator must pass context to the report-generation agent for the final output with proper source citations. What context-passing strategy provides the best balance of completeness and efficiency?

Pass a condensed summary of all prior stages that preserves the main findings and attributes them to sources by name only.

Pass the synthesis draft together with a structured source index that maps key claims to their source URLs and relevant excerpts.

Pass only the synthesis draft and use a separate post-processing pipeline to match claims to sources and insert citations after report generation.

Pass the complete accumulated context from all prior agents.

NO.20 After investigating a billing dispute for more than 25 turns, you determine that duplicate charges resulted from a payment-gateway timeout triggering retry logic. The required refund of $847 exceeds your $500 authorization limit, so you must invoke escalate_to_human. The human agent will not have access to the conversation transcript. What context should you pass to enable effective resolution?

The complete conversation transcript containing every message and tool result.

The customer’s original complaint verbatim together with excerpts from the tool results showing the duplicate transactions.

A structured summary containing the customer identifier, verified root cause, refund amount, relevant transaction identifiers, actions already attempted, and recommended next action.

Only the diagnosis and refund amount.

NO.21 You are building a multi-agent research system using the Claude Agent SDK. A coordinator agent delegates to specialized subagents: one searches the web, one analyzes documents, one synthesizes findings, and one generates reports. The system researches topics and produces comprehensive, cited reports.
The coordinator agent has AgentDefinition objects configured for all four specialized subagents, each with appropriate descriptions, prompts, and tool restrictions. During testing, you notice that the coordinator correctly reasons about when to delegate-it generates messages such as, “I’ll ask the web-search agent to find sources on this topic”-but no subagent execution ever occurs. The coordinator then proceeds as if the delegation happened and continues with incomplete information. Logs show no errors.
What is the most likely cause?

The AgentDefinition objects are configured correctly, but the coordinator’s system prompt does not explicitly list the available subagent types, preventing the model from knowing that they can be invoked.

Subagent context isolation means task descriptions from the coordinator do not automatically reach subagents; you must configure explicit context forwarding in ClaudeAgentOptions.

The coordinator’s allowedTools configuration does not include Agent-formerly named Task-so it cannot invoke the tool required to spawn subagents.

The coordinator’s max_tokens setting is too low, causing the subagent tool invocation to be truncated before the subagent type can be specified.

NO.22 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?

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

Add 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.

Build 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.

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

NO.23 Your automated review calls the Claude API for each pull request, using tool_use with a report_findings tool that returns a JSON array of finding objects. Each object contains file_path, line_number, severity, category, and description. During testing on a large pull request touching more than 30 files, the response reaches the max_tokens limit and is truncated in the middle of the JSON, causing your pipeline’s parser to fail. What is the most effective way to handle this?

Split the review into multiple API calls that each analyze a subset of the changed files, and then merge the resulting findings arrays.

Increase max_tokens to the model’s maximum and instruct Claude to keep each finding description under 50 words.

Switch from tool_use to prompting Claude to return findings as a Markdown list.

Add retry logic that detects truncated JSON and resends the request with instructions to report only critical- and high-severity findings.

NO.24 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.
Your extraction pipeline processes restaurant menus and must output structured JSON with fields for item names, descriptions, prices, and dietary tags. Some menus use inconsistent formatting-prices as “$12” vs
“12.00”, dietary info as icons vs text.
What’s the most reliable approach?

Use separate extraction calls for each field to ensure consistent handling of each type.

Define a strict output schema and include format normalization rules in your prompt.

Request multiple extraction attempts per document and select the most common format.

Extract data as-is and normalize formats in post-processing code after Claude returns.

NO.25 You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate repetitive tasks. It uses the built-in tools (Read, Write, Bash, Grep, Glob) and integrates with Model Context Protocol (MCP) servers.
Your agent has spent 25 minutes exploring a game engine’s rendering subsystem-reading shader code, buffer management, and frame synchronization logic. An engineer now asks it to understand how the physics engine integrates with rendering for collision debug overlays. You notice recent responses reference “typical rendering patterns” rather than the specific VulkanPipeline and FrameGraph classes it discovered earlier.
What’s the most effective approach?

Spawn a sub-agent to explore physics independently, then manually synthesize its findings with the rendering knowledge accumulated in the main conversation.

Use /clear to reset context completely, then start fresh with physics exploration using file paths from the project’s CLAUDE.md.

Summarize key rendering findings, then spawn a sub-agent for physics exploration with that summary in its initial context.

Continue in the current context with more targeted prompts referencing the specific classes by name.

NO.26 You have configured the system so that all four subagents have access to the complete set of 18 tools. During testing, agents frequently call tools outside their specialization-the synthesis agent attempts web searches, and the report generator tries to analyze documents. What is the primary cause of this poor tool-selection behavior?

The agents’ role descriptions in their system prompts conflict with having access to tools outside those roles.

The tool definitions consume too much context-window space, leaving insufficient room for task content.

The coordinator cannot track which capabilities each subagent has, leading to misrouted tasks.

Choosing from 18 tools instead of four or five relevant tools increases decision complexity beyond reliable selection thresholds.

NO.27 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.
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?

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

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

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

Randomly sample 5% of extractions for review.

NO.28 You are integrating Claude Code into your Continuous Integration/Continuous Deployment (CI/CD) pipeline.
The system runs automated code reviews, generates test cases, and provides feedback on pull requests. You need to design prompts that provide actionable feedback and minimize false positives.
Your pipeline includes a release-notes generation step that classifies and summarizes approximately 200 commits at the end of each weekly release cycle. Each commit is currently sent as a separate Messages API request using a Sonnet-tier Claude model. The release notes are not needed until the following morning, providing approximately 12 hours of acceptable latency.
Your team must reduce the per-token API cost while retaining the same model, prompts, and output quality.
Which approach satisfies all these constraints?

Issue the 200 Messages API requests concurrently because parallel execution reduces the per-token price.

Submit the 200 requests through the Message Batches API with unique custom_id values and retrieve the results after the batch finishes.

Concatenate all 200 commit messages into one Messages API request because reducing the number of requests always reduces token costs.

Replace the Sonnet-tier model with a Haiku-tier model to obtain a lower per-token price.

NO.29 You are building a structured data-extraction system using Claude. The system extracts information from unstructured documents, validates output against JSON schemas, and integrates the results with downstream systems.
Monitoring reveals that specifications sometimes appear inconsistently within source documents. For example, a summary section might state “Battery: 4000 mAh,” while the detailed specifications table states
“Battery: 4200 mAh.” Your current schema contains a single battery_capacity field.
This inconsistency occurs in approximately 15% of documents, and historical analysis confirms that the detailed specifications table is accurate 90% of the time.
What is the most effective approach?

Change the field to an array that captures every discovered value and its source location, leaving downstream systems to apply precedence rules.

Reject every extraction containing conflicting values and require the source document to be corrected before processing continues.

Add extraction instructions specifying that values from the detailed specifications table take precedence when conflicting values exist, while retaining the single-value schema.

Add a conflict_detected Boolean field and route every affected document for manual review.

NO.30 You are building a customer support resolution agent using the Claude Agent SDK. The agent handles high- ambiguity requests like returns, billing disputes, and account issues. It has access to your backend systems through custom Model Context Protocol (MCP) tools ( get_customer , lookup_order , process_refund , escalate_to_human ). Your target is 80%+ first-contact resolution while knowing when to escalate.
You’re implementing the escalation logic for when the agent should call escalate_to_human . Your team proposes four different approaches for triggering escalation.
Which approach will most reliably identify cases that genuinely require human intervention?

Build a rules engine that maps specific issue types, customer segments, and product categories to escalation decisions, removing the need for model judgment calls.

Instruct the agent to escalate when the customer requests a human, when the issue requires policy exceptions, or when the agent cannot make meaningful progress.

Configure the agent to escalate after three consecutive tool calls that fail to resolve the customer’s stated issue, ensuring a reasonable attempt before involving a human.

Implement sentiment analysis that monitors for frustration indicators (negative language, repeated questions, exclamation marks) and triggers escalation when the frustration score exceeds a configured threshold.

NO.31 When analyzing complex legal cases that cite multiple precedents, the document-analysis subagent processes each precedent sequentially. A landmark case citing 12 precedents takes more than three minutes to analyze completely. What is the most effective way to reduce this latency while preserving the coordinator’s ability to monitor and debug the system?

Have the coordinator spawn parallel document-analysis subagents, each handling a subset of precedents, and then aggregate the results before synthesis.

Enable the document-analysis subagent to spawn its own specialized subagents dynamically when it encounters cases with many citations.

Create a recursive agent hierarchy where analysis agents subdivide work among child agents until reaching single-precedent granularity.

Implement a message queue where precedent-analysis tasks are processed asynchronously by a pool of worker agents.

NO.32 You are building a customer support resolution agent using the Claude Agent SDK. The agent handles high- ambiguity requests like returns, billing disputes, and account issues. It has access to your backend systems through custom Model Context Protocol (MCP) tools ( get_customer , lookup_order , process_refund , escalate_to_human ). Your target is 80%+ first-contact resolution while knowing when to escalate.
The agent verifies customer identity through a multi-step process before resetting passwords. During testing, you notice that after the customer answers the third verification question, the agent asks them to provide their name again, as if the earlier exchange never happened.
What’s the most likely cause of this behavior?

The prompt lacks instructions telling Claude to remember information across multiple exchanges.

The conversation history isn’t being passed in subsequent API requests.

The verification tool is clearing the agent’s internal state after each successful validation step.

Claude’s memory retention is limited to two conversational turns by default, requiring explicit configuration to extend it.

NO.33 After deploying automated code review, developers report that approximately 35% of flagged findings are false positives falling into consistent patterns: style suggestions contradicting team conventions, security warnings for patterns that are safe in your deployment context, and performance suggestions that would degrade your specific use case. You want to reduce false positives while maintaining the ability to catch genuine issues. Which approach best enables the model to generalize its judgment to novel code patterns it has not seen before?

Implement post-processing that uses keyword matching to filter out findings containing terms such as
“convention,” “context-dependent,” or “trade-off.”

Include few-shot examples in your prompt showing annotated code snippets that distinguish acceptable patterns from genuine issues in each category.

Create a comprehensive written specification of all patterns that should not be flagged, and then include the full documentation in the system prompt.

Add instructions to your system prompt to “be conservative,” “only flag definite issues,” and “consider that some patterns may be intentional.”

NO.34 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.
Your system must extract event details from calendar invitations and output JSON that strictly conforms to a schema with fields for title, date, time, location, and attendees. Downstream systems reject any malformed or non-conformant JSON.
What approach provides the most reliable schema compliance?

Pre-fill Claude’s response with an opening brace to force JSON output, then complete and parse the response.

Append instructions like “Output only valid JSON matching the schema exactly” and implement retry logic to re-prompt when JSON parsing fails.

Define a tool with your target schema as input parameters and have Claude call it with the extracted data.

Include detailed JSON formatting instructions and the target schema in your prompt, then parse Claude’ s text response as JSON.

NO.35 You are building a multi-agent research system using the Claude Agent SDK. A coordinator agent delegates to specialized subagents: one searches the web, one analyzes documents, one synthesizes findings, and one generates reports. The system researches topics and produces comprehensive, cited reports.
A user expands the research system beyond its original web-search agent by adding specialized data sources.
A financial API agent returns structured JSON containing revenue, margins, and growth rates. A news- monitoring agent returns prose summaries of recent developments. A patent-analysis agent returns structured lists of technology areas. The synthesis agent combines these results into executive briefings. Currently, it converts everything into bullet points, causing financial comparisons to lose tabular clarity and news summaries to lose their narrative flow.
What change would most improve briefing quality?

Standardize all subagent outputs as prose summaries with inline citations.

Add a format-conversion layer that transforms every subagent output into a common intermediate representation.

Update the synthesis agent to render each content type appropriately-for example, financial data as tables, news as prose, and patent areas as structured lists.

Standardize all subagent outputs as JSON containing claim , evidence , source , and confidence fields.

Real Anthropic CCAR-F Exam Questions [Updated 2026]: https://www.prepawaypdf.com/Anthropic/CCAR-F-practice-exam-dumps.html

Anthropic CCAR-F Exam Questions (Updated 2026) 100% Real Question Answers [Q13-Q35]

Anthropic CCAR-F Exam Syllabus Topics:

admin

Leave a Reply Cancel reply