Get Updated Anthropic CCAR-F Exam Questions

QUESTION 1

Production logs show that when the agent handles complex billing disputes requiring 6+ tool calls, it sometimes exhausts its max_turns limit after gathering data but before completing resolution or escalating. The team’s goal is to guarantee that every customer interaction ends with either a completed resolution or a human handoff, regardless of how the agent loop terminates. Which approach achieves this guarantee?

A

Add system prompt instructions telling the agent to call escalate_to_human with a summary of its findings whenever it determines it cannot complete resolution within its remaining actions.

B

Split the workflow into two sequential agent invocations – a first agent gathers information via get_customer and lookup_order, then a second agent receives that data and handles process_refund or escalate_to_human, each with separate turn budgets.

C

Add orchestration-layer code that checks the agent’s outcome after each loop termination – if the loop ended without a completed resolution or escalation, programmatically call escalate_to_human with the accumulated conversation context and tool results.

D

Implement a pre-tool-use hook that counts tool invocations and terminates the loop with an automatic escalation once the agent reaches 80% of its max_turns limit.

Correct Option: C

✅ Option C (Correct)Reasoning: Orchestration-layer code provides a robust safety net. By checking the agent's final state after any loop termination, it can programmatically ensure an escalation if the agent neither completed resolution nor explicitly escalated. This guarantees the required outcome regardless of how the agent's internal process terminated, including due to max_turns exhaustion.❌ Why the other choices are incorrect:* Option A is incorrect: Relying on agent instructions is not a guarantee when max_turns is exhausted, as the agent might not get the chance to execute the escalation before termination.* Option B is incorrect: Splitting the workflow only segments the problem; each agent invocation still faces the max_turns issue, so the second agent could still exhaust turns before escalating.* Option D is incorrect: A pre-tool-use hook escalating at 80% of max_turns is a heuristic that might prevent resolution and is not a universal guarantee for all types of terminations or turn exhaustion scenarios.

Reference: https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html (General concept of agent orchestration/supervision)

QUESTION 2

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 the agent to understand how the caching layer works before adding a new cache invalidation trigger. After initial Grep searches, the agent has identified that caching logic spans 15 files including decorators, middleware, and service classes (~8,000 lines total). What’s the most effective next step for building understanding while managing context constraints?

A

Use the Read tool to sequentially load all 15 files, building complete understanding across the full caching implementation.

B

Use Glob to find files matching common caching patterns (cache.py, caching/), prioritize the largest files by reading them first, then check smaller files for gaps.

C

Analyze imports and class hierarchies to identify the base cache class, Read that file to understand the interface, then trace specific invalidation implementations.

D

Use Grep to search for “invalidate” and “expire” patterns across all files, then Read only those specific line ranges with minimal surrounding context.

Correct Option: C

✅ Option C (Correct)
Reasoning: Analyzing imports and class hierarchies to identify the base cache class allows the agent to understand the system's architecture and interface first. This structured, top-down approach efficiently manages context by focusing on high-level design before delving into specific implementation details like invalidation, which is crucial for adding a new trigger effectively.

❌ Why the other choices are incorrect:

Option A is incorrect: Loading 8,000 lines of code sequentially is highly likely to exceed the agent's context window, making comprehensive analysis and reasoning impractical.
Option B is incorrect: The agent has already identified the relevant 15 files. Prioritizing reading by file size does not inherently provide architectural understanding and might still overwhelm the context with details.
Option D is incorrect: While searching for specific patterns is useful, reading only isolated line ranges with minimal surrounding context can lead to a fragmented understanding of the overall caching mechanism, which is insufficient for safely adding a new invalidation trigger.

Reference: https://docs.anthropic.com/claude/reference/agents-overview (General principles of Claude Agent SDK and context management)

QUESTION 3

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 codebase exploration tool stores session IDs to allow engineers to continue investigations across work sessions. An engineer spent an hour yesterday analyzing a legacy authentication module, building context about its architecture and dependencies. They want to continue today. The session ID is valid, but version control shows 3 of the 12 files the agent previously read were modified overnight by a teammate's merge. What approach best balances efficiency and accuracy?

A

Start fresh session to ensure the agent works with current codebase state without stale assumptions

B

Resume the session and inform the agent which specific files changed for targeted re-analysis

C

Resume the session and immediately have the agent re-read all 12 previously analyzed files

D

Resume the session without informing the agent about the changed files

Correct Option: B

✅

Option B (Correct)

Reasoning: Resuming the session and specifically informing the agent which files changed (targeted re-analysis) offers the best balance. It ensures accuracy for the modified files while preserving the valuable context built for the 9 unchanged files, optimizing efficiency by avoiding unnecessary reprocessing. The agent can then update its internal model efficiently.

❌

Why the other choices are incorrect:

Option A is incorrect: Starting a fresh session discards all previously built context, which is highly inefficient given an hour of prior analysis. It ensures accuracy but sacrifices efficiency significantly.
Option C is incorrect: Rereading all 12 files, including the 9 unchanged ones, is less efficient than targeted re-analysis. While it ensures accuracy, it performs unnecessary work compared to focusing only on the modified files.
Option D is incorrect: Resuming without informing the agent about changes leads to inaccurate information for 3 files, causing potential errors and misleading outputs. This severely compromises accuracy and could lead to wasted effort.

Reference: https://docs.anthropic.com/claude/reference/agents-overview

QUESTION 4

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 needs to insert a new helper function into the middle of a 150-line utility module, between two existing functions. The Edit tool fails because its old_string parameter cannot find unique text to match – the file has repetitive docstrings, variable names, and structural patterns. What's the most reliable way to complete this insertion?

A

Use Edit with an extremely long old_string capturing 30+ lines of context to guarantee uniqueness

B

Use Bash to append the function definition to the end of the file using heredoc syntax

C

Use Edit’s replace_all parameter to target a common pattern and embed the new function in the replacement text

D

Use Read to load the file, add the function at the appropriate location, then Write the updated file

Correct Option: D

✅ Option D (Correct)
Reasoning: This is the most reliable method. The agent can use the Read tool to load the entire file's content into memory. It can then programmatically parse the content, identify the exact insertion point based on context (e.g., by searching for surrounding function definitions or line numbers), insert the new function, and finally use the Write tool to overwrite the original file with the updated content. This bypasses the Edit tool's limitation with non-unique old_string matches, providing precise control over placement.
❌ Why the other choices are incorrect:
* Option A is incorrect: Using an extremely long old_string is a fragile workaround. Even a 30+ line string might not guarantee uniqueness in a highly repetitive codebase, and it makes the operation brittle if the surrounding context changes slightly.
* Option B is incorrect: Appending the function to the end of the file using Bash does not meet the requirement of inserting it "in the middle... between two existing functions."
* Option C is incorrect: The replace_all parameter is designed to replace all occurrences of a pattern. Using it to embed a new function would likely result in multiple, incorrect insertions or unwanted replacements if the common pattern appears elsewhere in the file.

Reference: https://docs.anthropic.com/claude/reference/agent-sdk-tools

QUESTION 5

Your infrastructure-as-code repository includes Terraform modules (/terraform/), Kubernetes manifests (/kubernetes/), and CI/CD pipeline scripts (/pipelines/). Each requires different conventions, but your single root CLAUDE.md has grown to 500+ lines. When developers work on Kubernetes files, Terraform-specific rules load into context unnecessarily, consuming tokens.

What is the best approach to reorganize so only relevant guidance loads when editing specific file types?

A

Split content into subdirectory CLAUDE.md files (/terraform/CLAUDE.md, /kubernetes/CLAUDE.md), so Claude loads directory-specific guidance.

B

Keep the root CLAUDE.md and use @path/to/import syntax to modularly include tool-specific guidance files from separate documents.

C

Restructure the root CLAUDE.md into clearly labeled sections with headers (e.g, “## Terraform Conventions”), improving organization and readability.

D

Create files in .claude/rules/ with YAML frontmatter path-scoping (e.g., paths: [“terraform/**/*”]), loading rules only when editing matching files.

Correct Option: D

✅ (Correct)
Reasoning: Creating files within a .claude/rules/ directory with YAML frontmatter for path-scoping (e.g., paths: ["terraform/**/*"]) is the most effective approach. This method ensures that Claude only loads specific guidance rules when a developer is editing files that match the defined paths. This precisely addresses the problem of irrelevant context loading and unnecessary token consumption by providing granular, conditional context tailored to the active file.

❌ Why the other choices are incorrect:

is incorrect: While splitting CLAUDE.md files into subdirectories can provide directory-specific context, it still loads the entire CLAUDE.md from that subdirectory. It doesn't offer the precise, file-type-specific, and conditional loading based on path-scoping that .claude/rules/ provides to avoid loading irrelevant content for specific file types within that directory.
is incorrect: An @path/to/import syntax primarily serves to modularize a single CLAUDE.md document for organizational purposes, not to conditionally load context based on the file being edited. The entire composite document would still be processed, consuming tokens for all included sections.
is incorrect: Restructuring the root CLAUDE.md with headers improves readability but does not prevent the entire 500+ line document from being loaded into context, nor does it selectively load sections based on the edited file. This would still lead to unnecessary token consumption.

Reference: https://docs.anthropic.com/claude/docs/best-practices-for-context

QUESTION 6

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.

After adding an MCP server with specialized code refactoring tools (extract_function, rename_variable, inline_function), You notice the agent still uses basic text manipulation via Write and Bash sed commands for refactoring tasks. The MCP server is connected and healthy. Examining the configuration, you find each MCP tool has a minimal description like “extract_function: Extracts a function from code.”

What’s the most effective way to improve adoption of the MCP refactoring tools?

A

Implement a request classifier that detects refactoring intent and automatically routes those requests to the MCP server before the agent processes them.

B

Remove the Write tool from the agent’s configuration for refactoring sessions so it must use the MCP tools for code modifications.

C

Accept this as expected behavior since simpler tools like sed are more predictable than specialized refactoring tools.

D

Enhance the MCP tool descriptions to explain when each tool is preferable to text manipulation and clarify expected inputs and outputs.

Correct Option: D

✅ Option D (Correct)Reasoning: Large language model agents rely on comprehensive tool descriptions to understand capabilities, context, and preferred usage. Enhancing MCP tool descriptions to highlight their specific advantages over generic text manipulation (like Bash sed) and detailing expected inputs/outputs enables the agent to make more informed and accurate tool selections for complex refactoring tasks.❌ Why the other choices are incorrect:Option A is incorrect: A request classifier is an external routing mechanism that bypasses the agent's tool selection logic. It doesn't address the root cause of why the agent isn't choosing the MCP tools itself based on its internal understanding.Option B is incorrect: Removing fundamental tools like 'Write' is a forceful workaround that could hinder other legitimate text manipulation needs and doesn't solve the agent's underlying tool selection deficiency.Option C is incorrect: Accepting this behavior contradicts the goal of improving adoption. Specialized refactoring tools are generally more robust and safer than generic text manipulation for complex code changes, making their non-adoption an issue, not expected behavior.

Reference: https://docs.anthropic.com/claude/docs/tool-use-overview

QUESTION 7

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.

Your monorepo contains shared coding standards in /docs/standards/ : security-rules.md (for services handling user data), testing-petterns.md (for all packages), and api-conventions.md (for API-facing services). Your 15 packages are organized by feature domain ( /packages/auth/, /packages/billing/, /packages/notifications/ , etc.) without naming conventions indicating which handle user data or expose APIs. Package maintainers are expected to configure their own local development settings, as they understand their package’s domain requirements. Currently, all package CLAUDE.md files duplicate all three standards, applying irrelevant guidance. What’s the most effective approach?

A

Create .claude/rules/ files for each standard with YAML frontmatter paths listing every package directory where that standard should apply.

B

Put all standards in the root CLAUDE.md with override instructions like “ignore security-rules.md when working in packages that don’t handle user data.”

C

Create a shared-stendards.md that uses @imports to combine all three standards, then have each package’s CLAUDE.md import that combined file.

D

Use @imports in each package’s CLAUDE.md to reference only the specific standard files relevant to that package, based on the maintainer’s domain knowledge.

Correct Option: D

✅ Option D (Correct) Reasoning: This approach enables package maintainers to configure their local CLAUDE.md files, importing only relevant standard files based on their package's domain. It eliminates irrelevant guidance, reduces duplication, and leverages maintainer expertise, aligning perfectly with distributed configuration requirements.❌ Why the other choices are incorrect: * Option A is incorrect: This centralizes configuration and path management, contradicting the requirement for maintainers to configure local settings and creating a maintenance burden. * Option B is incorrect: This approach relies on manual interpretation and ignores specific standards, which is prone to human error and lacks programmatic enforcement for effective compliance. * Option C is incorrect: This option would reintroduce the issue of applying all three standards to every package, regardless of relevance, thereby failing to eliminate irrelevant guidance and duplication.

Reference: https://docs.anthropic.com/claude/docs/managing-project-context

QUESTION 8

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?

A

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

B

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

C

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

D

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

Correct Option: B

✅ Option B (Correct)Reasoning: Summarizing key rendering findings condenses essential knowledge, addressing the agent's loss of specificity. Spawning a sub-agent for physics exploration with this summary enables specialized focus while maintaining crucial context for integration. This optimizes context management and promotes modularity for complex tasks.❌ Why the other choices are incorrect:* Option A is incorrect: Simply adding more targeted prompts may not resolve underlying context window limitations or the agent's difficulty retaining long-term, detailed specifics over extended interaction.* Option C is incorrect: Manually synthesizing findings is inefficient and contradicts the goal of using an autonomous agent to enhance productivity. It introduces a manual bottleneck.* Option D is incorrect: Resetting context completely discards all accumulated rendering knowledge. This is counterproductive, as the task specifically requires understanding the integration of physics with existing rendering details.

Reference: https://docs.anthropic.com/claude/reference/agents-and-tools

QUESTION 9

After integrating a local MCP server providing code analysis tools (analyze_dependencies, find_dead_code, calculate _complexity), you verify the server is healthy and tools appear in the tools/list response. However, you observe that the agent consistently uses Grep to search for import statements instead of calling analyze_dependencies –even when users explicitly ask about “code dependencies.”

Examining tool definitions reveals:

• MCP: analyze_ dependencies – “Analyzes dependency graph”

• Built-in: Grep – “Search file contents for a pattern using regular expressions. Returns matching lines with line numbers and surrounding context.”

What's the most effective approach to improve the agent's selection of MCP tools?

A

Add routing instructions to the system prompt specifying that dependency-related questions should use MCP tools rather than Grep.

B

Remove Grep from available tools when the MCP server is connected to eliminate functional overlap.

C

Split analyze_dependencies into granular tools ( list_imports, resolve_transitive_deps, detect_circular_deps) so each has a focused purpose less likely to overlap with Grep.

D

Expand MCP tool descriptions to detail capabilities and outputs—e.g., "Builds dependency graph showing direct imports, transitive dependencies, and cycles."

Correct Option: D

✅ Option D (Correct)Reasoning: The agent incorrectly prefers Grep because 'Analyzes dependency graph' might be too abstract. Expanding the MCP tool description to detail its specific capabilities, such as 'Builds dependency graph showing direct imports, transitive dependencies, and cycles,' clarifies its specialized purpose. This helps the LLM distinguish it from Grep's general search, leading to more accurate tool selection for dependency analysis.❌ Why the other choices are incorrect:* Option A is incorrect: While routing instructions can work, improving the tool's intrinsic description (D) is a more fundamental and scalable solution for guiding LLM selection based on the tool's actual capabilities.* Option B is incorrect: Removing Grep is an overly aggressive measure. Grep has legitimate uses beyond finding import statements, and its removal would limit the agent's overall functionality.* Option C is incorrect: Splitting tools into more granular ones might increase complexity without directly addressing the core issue of the LLM misunderstanding the specialized capabilities of the existing analyze_dependencies tool versus Grep.

Reference: https://docs.anthropic.com/claude/docs/tool-use

QUESTION 10

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.

When researching “renewable energy adoption,” the web search agent returns recent statistics (2024: 35% adoption) while the document analysis agent extracts data from internal reports (2021: 18% adoption). The synthesis agent incorrectly flags these as contradictory sources rather than recognizing the data shows growth over time. What change would best enable the synthesis agent to correctly interpret such temporal differences?

A

Instruct the synthesis agent to always treat the most recent data as authoritative and place older findings in a separate historical appendix.

B

Add a conflict resolution agent that automatically discards older data when newer data exists for the same metric.

C

Require subagents to include publication or data collection dates in their structured outputs.

D

Configure the web search agent to only return results from the past 6 months.

Correct Option: C

✅ Option C (Correct)Reasoning: The synthesis agent misinterprets the data because it lacks temporal context. By requiring subagents to include dates in their outputs, the synthesis agent gains the necessary metadata to recognize that the data points refer to different time periods, allowing it to correctly identify growth rather than contradiction.❌ Why the other choices are incorrect:* Option A is incorrect: This strategy requires the synthesis agent to already know which data is most recent, which it currently cannot do without date information.* Option B is incorrect: This is a simplistic conflict resolution rule that discards data, potentially losing valuable historical context. It also doesn't solve the underlying issue of the synthesis agent's inability to interpret temporal differences.* Option D is incorrect: Limiting the web search agent's scope prevents the system from observing trends over time, which is essential for understanding concepts like 'growth over time' in renewable energy adoption.

Reference: https://www.anthropic.com/claude

QUESTION 11

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.

Your team’s CLAUDE.md includes a rule: “Use 4-space indentation and always run Prettier formatting.” Despite this, code reviews reveal that roughly 30% of files Claude Code generates use inconsistent formatting – sometimes 2-space indentation, sometimes missing trailing commas. Adding emphasis (“IMPORTANT: You MUST use Prettier formatting”) reduces violations to about 15%, but doesn’t eliminate them. What is the most effective way to ensure all generated code is consistently formatted?

A

Configure a PostToolUse hook with an Edit|Write matcher that automatically runs Prettier on each file Claude modifies.

B

Split the formatting rules into path-scoped .claude/rules/files that load when Claude works on matching file types.

C

Extract the formatting rules into a dedicated skill that Claude loads automatically when generating code, with more detailed examples of correct formatting.

D

Add a Stop hook with a prompt-based check that evaluates whether generated code follows formatting standards and prompts Claude to fix violations.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 12

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?

A

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

B

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.

C

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

D

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.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 13

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.

A critical bug is affecting production users. Error logs show exceptions in the OrderProcessing module with a clear stack trace pointing to a specific function. You haven’t worked with this module before. What’s the most effective approach?

A

Start with direct execution to gather initial information, then switch to plan mode to design a comprehensive solution before implementing any changes.

B

Enter plan mode to explore the module’s architecture and dependencies before attempting any fixes.

C

Use plan mode to analyze the error in context of the module’s design, enumerate potential root causes, and prioritize fixes systematically.

D

Use direct execution to examine the stack trace, read the relevant code, and implement a fix once you identify the root cause.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 14

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 analyzed a complex service module –reading 23 source files, tracing request flows, and identifying error handling patterns. A developer wants to compare two testing strategies before committing to one: end-to-end tests with mocked external services vs. snapshot tests capturing expected outputs. They need to independently develop both approaches to evaluate trade-offs. How should you manage the sessions?

A

Start two fresh sessions, having each re-read the relevant source files before beginning.

B

Resume the analysis session with fork_session enabled, creating a separate branch for each testing strategy.

C

Export the analysis session's key findings to a file, then create two new sessions that reference this file.

D

Continue in the original session, developing end-to-end tests first, then snapshot tests sequentially.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 15

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.

After expanding the agent’s MCP tools with delivery-specific capabilities ( check_delivery_status , contact_driver , issue_credit , apply_promo_code , update_delivery_address , reschedule delivery ), the total tool count has grown from 4 to 10. Your evaluation suite shows tool selection accuracy has dropped from 88% to 71%. Log analysis reveals the majority of errors involve the agent selecting between semantically overlapping tools — calling issue_credit when process_refund was correct, and calling check_delivery_status when lookup_order already returns the needed data. Which approach structurally eliminates the semantic overlap identified in the logs as the error source?

A

Enable the tool search tool with defer_loading on the six new tools, keeping the original four always loaded, so the agent dynamically discovers specialized tools only when needed.

B

Split the tools across two sub-agents – a “financial resolution” agent with process_refund , issue_credit ,and apply_promo_code , and a “delivery operations” agent with the remaining delivery tools – with a coordinator routing between them.

C

Add few-shot examples to the system prompt demonstrating correct selection for each ambiguous tool pair, such as showing when issue_credit applies versus when process_refund is appropriate.

D

Consolidate semantically overlapping tools – merge issue_credit and process_refund into a single resolve_compensation tool with an action parameter, and fold check_delivery_status into lookup_order with an optional include_tracking flag.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 16

During testing, you find that when a customer says “I need a refund for my recent purchase,” the agent calls process _refund immediately – but populates the required order_id parameter with a plausible-looking but fabricated value instead of first calling lookup_order to retrieve the actual order ID. The refund call fails because the fabricated ID doesn’t exist. Which change directly addresses the root cause of the agent fabricating the order_id value?

A

Switch tool_choice from “auto” to “any” to force the agent to make a tool call on every turn.

B

Update the process_refund tool description to explicitly state that order_id must be obtained from a prior lookup_order call and must never be assumed or invented.

C

Pre-parse incoming customer messages to extract any order IDs mentioned, and inject them into the conversation context before passing to Claude.

D

Add server-side validation that checks whether the order_id exists in your database before executing the refund, returning an error to the agent if not found.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 17

Anthropic’s tool use documentation states: “Write instructive error messages. Instead of generic errors like ‘failed’, include what went wrong and what Claude should try next.” A billing dispute agent uses lookup_order, which catches all exceptions and returns a tool_result with is_error: true and the message “Tool execution failed”. Monitoring shows two failure modes: the agent retries the identical call until hitting the turn limit, or it immediately calls escalate_to_human without trying alternative tools. Which change follows the documented recommendation and gives Claude the information it needs to select the correct recovery action for each error type?

A

Implement retry logic with exponential backoff inside each tool implementation so transient errors are resolved transparently within the tool before any failure result is surfaced to Claude in the agentic loop.

B

Add an error classification step in the agentic loop that intercepts tool errors before Claude sees them, tags each as “retry,” “try_alternative,” or “escalate,” and appends that recommendation to the tool result.

C

Remove is_error: true and return the error details as normal tool content, so Claude reasons about the response as data rather than treating it as a flagged failure condition that biases retry behavior.

D

Return error-type-specific messages with Sis_error: true', e.g., '"Order not found—try get_customer to search by phone"' for data errors and • "Database timeout (transient)—retry should succeed"' for infrastructure errors.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 18

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?

A

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

B

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.

C

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

D

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.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 19

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.

During testing, you observe that in extended exploration sessions (30+ minutes), the agent starts giving inconsistent answers about code structure it discussed earlier. Engineers report having to repeat context about modules they’ve already explored. What's the most effective approach to address this?

A

Implement automatic context clearing every 15 minutes to ensure the agent starts with fresh, uncontaminated context.

B

Switch to a higher-capacity model tier to provide more context window space for accumulated exploration data.

C

Create summaries of all source files before exploration begins, loading only these compressed representations into context.

D

Have the agent maintain a scratchpad file that records key findings, referencing it for subsequent questions.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 20

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 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?

A

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

B

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

C

Use direct execution to make the change.

D

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

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 21

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 complex graph traversal algorithm with specific performance requirements and edge cases to handle (disconnected nodes, cycles, weighted edges). You want to structure your workflow for efficient iterative refinement with Claude. What approach will most effectively enable progressive improvement across multiple iterations?

A

Have Claude extensively research the algorithm and create a detailed implementation plan using extended thinking, then implement the complete solution based on that plan.

B

Provide Claude with a reference implementation from documentation, then ask it to rewrite the code to match your codebase style and add the required edge case handling, comparing outputs against the reference.

C

Provide Claude with a detailed natural language specification of the algorithm, including all requirements and edge cases. Review each output manually and provide descriptive feedback on what behavior needs to change.

D

Write a test suite covering expected behavior, edge cases, and performance requirements before implementation. Ask Claude to write code that passes the tests, then iterate by sharing test failures with each refinement request.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 22

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’ve documented API error handling conventions in a CLAUDE.md file at your project root, specifying that endpoint handlers should use a custom ApiError class. After several sessions, you notice Claude Code sometimes follows these conventions and sometimes uses generic try/catch blocks with string messages. The inconsistency appears random across different coding sessions. What’s the most efficient first diagnostic step?

A

Add a more detailed code examples to your CLAUDE.md showing the exact ApiError usage pattern for different endpoint types.

B

Run /memory to check which memory files are loaded and verify your CLAUDE.md is included.

C

Search for conflicting instructions in ~/.claude/CLauDe.md or ~/.claude/rules/ that might override your project conventions.

D

Create path-specific rules in .claude/rules/handlers.md with YAML frontmatter scoping the error handling instructions to your API handler files.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 23

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.

Your team has connected a custom MCP server that provides DevOps workflow templates. The server exposes several MCP prompts (such as deploy_checklist and incident_response) in addition to tools. How do these MCP prompts become accessible within Claude Code?

A

They are surfaced as @ -mentionable resources alongside files, fetched and attached to your message when referenced.

B

They are automatically prepended to every conversation as additional system-level context, influencing Claude’s behavior throughout the session.

C

They are added to Claude Code’s tool registry alongside the server’s tools, invoked automatically by the model when relevant to the task.

D

They appear as slash commands (e.g., mcp_servername_deploy_checklist) that you can invoke, with arguments passed after the command name.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 24

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?

A

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

B

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

C

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

D

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

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 25

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.

Your team has three requirements for Claude Code’s behavior in your project

1. Claude must never modify files in the db/migrations/ directory

2. Claude should prefer your custom logging module over console.log

3. All TypeScript files must be auto-formatted with Prettier after every edit

All three are currently written as instructions in your project’s CLAUDE.md. During a complex refactoring session, a developer discovers that Claude edited a migration file, violating requirement #1. How should you restructure these requirements across Claude Code's configuration mechanisms?

A

Add Edit(./db/migrations/**) to permissions.deny in the project settings, keep the logging preference in CLAUDE.md, and add a PostToolUse hook on the Edit tool that runs Prettier on changed TypeScript files.

B

Move all three requirements into .claude/rules/ as path-scoped rules: one targeting db/migrations/** that forbids editing those files, and others targeting **/*.ts for the logging convention and formatting instruction.

C

Rewrite all three requirements in CLAUDE.md using stronger directive language and add few-shot examples that demonstrate Claude refusing to edit migration files and running Prettier after edits.

D

Configure hooks for all three: a PreToolUse hook script that blocks Edit calls targeting db/migrations/,a PreToolUse hook script that adds logging convention context before edits, and a PostToolUse hook that runs Prettier after TypeScript edits.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 26

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’ve asked Claude to write a data migration script, but the initial output doesn’t correctly handle records with null values in required fields. What’s the most effective way to iterate toward a working solution?

A

Manually edit the generated code to fix the null handling, then continue working with Claude on other parts.

B

Add “think harder about edge cases” to your prompt and request a complete rewrite of the migration logic.

C

Describe the null value problem in detail and ask Claude to regenerate the entire script with improved edge case handling.

D

Provide a test case with example input containing null values and the expected output, then ask Claude to fix it.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 27

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 caching layer for API responses to speed up the /products endpoint. You have a rough idea–Redis with a 5-minute TTL–but you’re new to production caching and aren’t sure what other considerations a robust implementation requires. What’s the most effective way to start your iterative workflow?

A

Start with a minimal request: “Add Redis caching to /products with 5-minute TTL.” Add features and fix issues through follow-up prompts as problems surface during testing.

B

Write a specification with your known requirements and “TBD” markers for uncertain areas, having Claude propose solutions for each TBD as it implements.

C

Ask Claude to interview you about the caching requirements before implementing, surfacing considerations like invalidation strategies, cache layers, consistency guarantees, and failure modes.

D

Use plan mode to analyze the current/products endpoint implementation, then provide your caching requirements once Claude explains how the existing code is structured.

Premium Solution Locked

Unlock all 137 answers & explanations

QUESTION 28

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.

Your team wants Claude to follow a detailed code review checklist (8 items covering API changes, test coverage, documentation, security, etc.) when reviewing pull requests. The team also uses Claude extensively for other tasks: writing new features, debugging production issues, and generating documentation. Currently, developers paste the checklist at the start of each review session. Which approach best addresses this workflow need?

A

Create a /review slash command containing the checklist, invoked when starting reviews.

B

Create a dedicated review subagent with the checklist embedded in its configuration.

C

Configure plan mode as the default for code review sessions.

D

Add the checklist to the project’s CLAUDE.md file under a “Code Review” section.

Premium Solution Locked

Unlock all 137 answers & explanations

Anthropic Claude Certified Architect - Foundations (CCAR-F)

Test the Practice Engine

Premium Bundle

Standard Simulation

Basic Tier

Verified Community

Success Network

Exam Overview

Skills Measured

Career Path

Common Questions

Is the material up to date?

What format do I get?

Is there a guarantee?

When do I get the download?

Free Study Guide Samples

Full Question Bank Locked

Customer Reviews

David M.

Sarah J.

Michael C.

Need Assistance?

Get Exam Updates