Summer Sale Limited Time 75% Discount Offer - Ends in 0d 00h 00m 00s - Coupon code = simple75

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

Exam CCAR-F Premium Access

View all detail and faqs for the CCAR-F exam

Practice at least 50% of the questions to maximize your chances of passing.
Viewing page 3 out of 5 pages
Viewing questions 21-30 out of questions
Questions # 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 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?

Options:

A.

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

B.

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

C.

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.

D.

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

Questions # 22:

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. Reviews are posted asynchronously and do not block pull-request creation. Developers report that reviews consistently miss bugs involving cross-file interactions—for example, a pull request renames a function’s parameters, but the review does not flag callers in other files that still use the old parameter names. Post-release analysis shows that cross-file bugs account for 35% of production incidents from reviewed pull requests. What is the most effective change to your review design?

Options:

A.

Redesign the review as a turn-limited agentic task in which the model can read files and search the codebase through tools, following references to verify cross-file findings.

B.

Add chain-of-thought instructions asking the model to list all external references in the diff and then reason step by step about how each change might affect callers in other files.

C.

Use static analysis to build a dependency graph of changed code, and then expand the prompt to include every file within two dependency hops of any changed file.

D.

Run parallel review passes for each changed file with its direct dependents included, and then aggregate and deduplicate the findings through a final summarization call.

Questions # 23:

The synthesis agent completes its initial pass but flags that three key research questions remain unanswered because the web-search and document-analysis agents did not find relevant information on those specific subtopics. The coordinator currently proceeds directly to report generation, producing reports with incomplete coverage. What change would most effectively improve research completeness?

Options:

A.

Have the coordinator evaluate the synthesis output for gaps, then redelegate targeted queries to the web-search and document-analysis agents before invoking synthesis again.

B.

Have the report-generation agent identify unanswered research questions so users understand the limitations of the final output.

C.

Increase the initial breadth of queries sent to the web-search and document-analysis agents to reduce the probability of missing relevant information.

D.

Give the synthesis agent direct access to web-search tools so it can autonomously fill knowledge gaps without returning control to the coordinator.

Questions # 24:

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 # 25:

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.

Your extraction pipeline occasionally receives responses that cannot be parsed as valid JSON, causing downstream processing failures. The current implementation prompts Claude to return JSON in the response text and then parses it.

What is the most reliable approach to ensure Claude returns valid, schema-compliant structured data?

Options:

A.

Add explicit formatting instructions to the prompt with JSON examples, emphasizing that Claude must return only valid JSON with no surrounding text.

B.

Use regular expressions to locate and extract JSON from the response text, handling cases where Claude includes explanatory text around the JSON block.

C.

Define a tool with a JSON schema specifying the expected structure, using tool use to constrain Claude’s output to schema-compliant JSON.

D.

Implement a retry loop that catches JSON parsing errors and re-prompts Claude with the error details, asking it to correct the malformed output.

Questions # 26:

The document-analysis agent has a single analyze_document tool that accepts a document and a free-text instruction parameter. During evaluation, requests such as “extract the key financial metrics” often return narrative summaries, while “summarize the methodology” sometimes returns raw data tables. The synthesis agent reports that 35% of analysis results require new requests with clarified instructions. What is the most effective way to improve reliability?

Options:

A.

Split the generic tool into purpose-specific tools—extract_data_points, summarize_content, and verify_claim_against_source—each with defined input and output contracts.

B.

Retain the single tool but add an analysis_type enum requiring explicit selection among extraction, summarization, and verification modes.

C.

Have the coordinator preclassify each analysis request before passing instructions to the document-analysis agent.

D.

Enhance the tool description with detailed examples showing how different instruction phrasings should map to different output formats.

Questions # 27:

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 # 28:

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

Options:

A.

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

B.

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

C.

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

D.

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.

Questions # 29:

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 provides detailed step-by-step instructions to the web-search subagent, specifying exact search queries, source priorities, and date filters. Production monitoring reveals three issues: (1) the subagent reports “insufficient results” rather than trying alternative approaches when the pre-specified searches fail, (2) research quality drops for emerging topics that do not match expected patterns, and (3) the subagent rarely surfaces valuable tangential sources.

What is the most effective way to improve subagent adaptability?

Options:

A.

Specify research goals and quality criteria—coverage breadth, source diversity, and recency—rather than procedural steps, allowing the subagent to determine its search strategy.

B.

Remove procedural details entirely, delegating with simple goals such as “research X thoroughly” and relying on the subagent’s general capabilities.

C.

Add explicit fallback directives to the detailed instructions: “If specified searches yield fewer than N results, attempt alternative query formulations before reporting failure.”

D.

Implement a topic-classification step where the coordinator categorizes requests as “well-defined” or “exploratory” and uses different instruction styles for each category.

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.

Your pipeline runs:

PROMPT= ' You are a code reviewer. Analyze the provided diff for bugs, security issues, and style violations. '

claude -p \

--dangerously-skip-permissions \

--system-prompt " $PROMPT " \

< diff.txt

The reviews complete and return feedback, but Claude only comments on the piped diff text—it never reads surrounding files in the checked-out repository to understand broader context, even when the diff modifies a function called by many other modules.

Which change to the invocation will cause Claude to inspect related repository files while still applying your custom review instructions?

Options:

A.

Remove --system-prompt entirely and place the review instructions in a CLAUDE.md file, because --system-prompt is incompatible with tool use under -p.

B.

Keep --system-prompt and add --allowedTools " Read,Glob,Grep " , because non-interactive -p mode otherwise disables filesystem tools.

C.

Stop piping the diff through standard input and embed it inside the prompt, so Claude Code treats the invocation as an agentic session.

D.

Replace --system-prompt with --append-system-prompt and explicitly instruct Claude to inspect related repository files whenever broader context is needed.

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