Summer Certification Limited Time 70% Discount Offer - Ends in 0d 00h 00m 00s - Coupon code = getmirror

Pass the Anthropic Claude Certified Architect CCAR-F Questions and answers with ExamsMirror

Practice at least 50% of the questions to maximize your chances of passing.
Exam CCAR-F Premium Access

View all detail and faqs for the CCAR-F exam


0 Students Passed

0% Average Score

0% Same Questions
Viewing page 3 out of 5 pages
Viewing questions 21-30 out of questions
Questions # 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.

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?

Options:

A.

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

B.

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

C.

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

D.

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

Questions # 22:

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 find all callers of a function before removing it. The function is defined in a core library but is also exposed through wrapper modules that rename the function for domain-specific use (e.g., calculateTax in the library becomes computeOrderTax in the orders module).

What exploration strategy will most reliably identify all callers?

Options:

A.

Use Grep to find all files that import from the library or wrapper modules, then read each file to check whether it uses the function.

B.

Use Grep to search for the function’s original name across the codebase.

C.

Read the library and wrapper modules to identify all exposed names for the function, then Grep for each name across the codebase.

D.

Search for the function name in project documentation to understand intended usage patterns and navigate to documented integration points.

Questions # 23:

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?

Options:

A.

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.

B.

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

C.

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

D.

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

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

Options:

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.

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.

D.

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.

Questions # 25:

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?

Options:

A.

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

B.

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

C.

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

D.

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

Questions # 26:

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.

Compliance requires that refunds exceeding $500 must automatically escalate to a human agent—this rule cannot be left to model discretion. Despite clear system prompt instructions, production logs show the agent occasionally processes high-value refunds directly (3% failure rate).

How should you achieve guaranteed compliance?

Options:

A.

Add few-shot examples to the prompt showing correct escalation behavior at various refund amounts ($400, $500, $600).

B.

Strengthen the system prompt with emphatic language: “CRITICAL POLICY: Refunds over $500 MUST trigger human escalation. NEVER process these directly.”

C.

Modify the refund tool to return an error with message “Amount exceeds policy limit—please escalate” when the threshold is exceeded.

D.

Implement a hook to intercept tool calls, when the refund process amount exceeds $500, block it and invoke human escalation.

Questions # 27:

After the web-search and document-analysis subagents complete their tasks, the coordinator needs to spawn the synthesis subagent to synthesize the findings. What is the correct approach for providing the synthesis subagent with the information it needs?

Options:

A.

Pass reference identifiers and configure the subagent with read access to a shared memory store where the other subagents deposited their results.

B.

Include the complete findings from both subagents directly in the synthesis subagent’s prompt.

C.

Provide the subagent with tool definitions that allow it to request outputs from the other subagents through callbacks.

D.

Spawn the subagent with only a brief task description, relying on automatic context inheritance from the coordinator.

Questions # 28:

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 system implements automatic retries when validation fails. On each retry, the specific validation error is appended to the prompt. This retry-with-error-feedback approach resolves most failures within 2–3 attempts.

For which failure pattern would additional retries be LEAST effective?

Options:

A.

The model extracts keywords as a nested object organized by category when the schema requires a flat array of strings.

B.

The model extracts “et al.” for co-authors when the full list exists only in an external document not in the input.

C.

The model extracts citation counts as locale-formatted strings (“1,234”) when the schema requires integers.

D.

The model extracts dates as ISO 8601 datetime strings (“2023-03-15T00:00:00Z”) when the schema requires only the date portion (YYYY-MM-DD).

Questions # 29:

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 returns 4 hours after their initial session about the same billing dispute. The previous 32-turn session contains lookup_order results showing “Status: PENDING, Expected resolution: 24–48 hours.” In testing, you observe that when resuming sessions with stale tool results, the agent often references the outdated data in responses (e.g., “I see your refund is still being processed”) even after subsequent fresh tool calls return different information.

What approach most reliably handles returning customers?

Options:

A.

Resume with full history and configure the agent to automatically re-call all previously used tools at session start to ensure data freshness.

B.

Resume with full history and add a system prompt instruction telling the agent to always prefer the most recent tool results when multiple calls to the same tool exist in context.

C.

Resume with full history but filter out previous tool_result messages before resuming, keeping only the human/assistant turns so the agent must re-fetch needed data.

D.

Start a new session, inject a structured summary of the previous interaction (issue type, actions taken, resolution status), then make fresh tool calls before engaging.

Questions # 30:

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.

During initial testing of the automated review pipeline, you notice that reviews on 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 once it reaches both a fixed iteration count and a fixed dollar amount, enforced by Claude Code itself rather than by the surrounding job runner.

Which configuration change directly enforces both per-invocation caps?

Options:

A.

Switch the --model flag to a smaller, less expensive model so each iteration uses fewer tokens and has a lower per-call cost.

B.

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

C.

Add --max-turns 10 --max-budget-usd 2.00 to the claude -p invocation to cap iterations and spending.

D.

Set --permission-mode dontAsk to automatically deny tool-permission requests not included in the explicitly allowed set.

Viewing page 3 out of 5 pages
Viewing questions 21-30 out of questions
TOP CODES

TOP CODES

Top selling exam codes in the certification world, popular, in demand and updated to help you pass on the first try.