Getting CCAR-F certification is an important step in your career, but preparing for it can feel challenging. At skillcertexams, we know that having the right resources and support is essential for success. That’s why we created a platform with everything you need to prepare for CCAR-F and reach your certification goals with confidence.
Your Journey to Passing the Claude Certified Architect – Foundations CCAR-F Exam
Whether this is your first step toward earning the Claude Certified Architect – Foundations CCAR-F certification, or you're returning for another round, we’re here to help you succeed. We hope this exam challenges you, educates you, and equips you with the knowledge to pass with confidence. If this is your first study guide, take a deep breath—this could be the beginning of a rewarding career with great opportunities. If you’re already experienced, consider taking a moment to share your insights with newcomers. After all, it's the strength of our community that enhances our learning and makes this journey even more valuable.
Why Choose SkillCertExams for CCAR-F Certification?
Expert-Crafted Practice Tests
Our practice tests are designed by experts to reflect the actual CCAR-F practice questions. We cover a wide range of topics and exam formats to give you the best possible preparation. With realistic, timed tests, you can simulate the real exam environment and improve your time management skills.
Up-to-Date Study Materials
The world of certifications is constantly evolving, which is why we regularly update our study materials to match the latest exam trends and objectives. Our resources cover all the essential topics you’ll need to know, ensuring you’re well-prepared for the exam's current format.
Comprehensive Performance Analytics
Our platform not only helps you practice but also tracks your performance in real-time. By analyzing your strengths and areas for improvement, you’ll be able to focus your efforts on what matters most. This data-driven approach increases your chances of passing the CCAR-F practice exam on your first try.
Learn Anytime, Anywhere
Flexibility is key when it comes to exam preparation. Whether you're at home, on the go, or taking a break at work, you can access our platform from any device. Study whenever it suits your schedule, without any hassle. We believe in making your learning process as convenient as possible.
Trusted by Thousands of Professionals
Over 10000+ professionals worldwide trust skillcertexams for their certification preparation. Our platform and study material has helped countless candidates successfully pass their CCAR-F exam questions, and we’re confident it will help you too.
What You Get with SkillCertExams for CCAR-F
Realistic Practice Exams: Our practice tests are designed to the real CCAR-F exam. With a variety of practice questions, you can assess your readiness and focus on key areas to improve.
Study Guides and Resources: In-depth study materials that cover every exam objective, keeping you on track to succeed.
Progress Tracking: Monitor your improvement with our tracking system that helps you identify weak areas and tailor your study plan.
Expert Support: Have questions or need clarification? Our team of experts is available to guide you every step of the way.
Achieve Your CCAR-F Certification with Confidence
Certification isn’t just about passing an exam; it’s about building a solid foundation for your career. skillcertexams provides the resources, tools, and support to ensure that you’re fully prepared and confident on exam day. Our study material help you unlock new career opportunities and enhance your skillset with the CCAR-F certification.
Ready to take the next step in your career? Start preparing for the Anthropic CCAR-F exam and practice your questions with SkillCertExams today, and join the ranks of successful certified professionals!
You are building a customer support resolution agent using the Claude Agent SDK. The agenthandles high-ambiguity requests like returns, billing disputes, and account issues. It hasaccess to your backend systems through custom Model Context Protocol (MCP) tools(get_customer, lookup_order, process_refund, escalate_to_human). Your target is 80%+ firstcontact resolution while knowing when to escalate.Anthropic’s tool use documentation states: “Write instructive error messages. Instead ofgeneric errors like ‘failed’, include what went wrong and what Claude should try next.” A billingdispute agent uses lookup_order, which catches all exceptions and returns a tool_result withis_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 callsescalate_to_human without trying alternative tools.Which change follows the documented recommendation and gives Claude the information itneeds to select the correct recovery action for each error type?
A. Implement retry logic with exponential backoff inside each tool implementation sotransient errors are resolved transparently within the tool before any failure result issurfaced to Claude in the agentic loop. B. Return error-type-specific messages with is_error: true, e.g., “Order not found—tryget_customer to search by phone” for data errors and “Database timeout (transient)—retryshould succeed” for infrastructure errors. C. Remove is_error: true and return the error details as normal tool content, so Claudereasons about the response as data rather than treating it as a flagged failure conditionthat biases retry behavior. D. Addanerror classification step in the agentic loop that intercepts tool errors beforeClaude sees them, then routes to hardcoded retry or escalation logic.
Answer: B EXPERT VERIFICATION The original answer was correct.
The original answer was correct: it is the only option that follows the documented guidance to
return instructive, error-type-specific messages to the model.
EXPLANATION
In an agentic loop, tool results are the model's only sensory channel. A generic string like "Tool
execution failed" is informationally empty, so the model cannot distinguish a permanent data
condition from a transient infrastructure condition, and the two observed pathologies follow
directly: identical retries until the turn limit, or premature escalation. Anthropic's tool use
guidance is explicit that error messages should say what went wrong and what to try next,
because the model treats a tool result as evidence and will plan its next action from it.
Returning "Order not found- try get_customer to search by phone" tells Claude the state is
permanent for this input and points at a concrete alternative path, while "Database timeout
(transient)- retry should succeed" tells Claude that the same call is worth repeating. Keeping
is_error: true is correct and important: the flag marks the block as a failure so the model does
not mistake the error text for legitimate order data, and it is the standard signal in both the
Messages API tool_result block and the MCP isError field. In enterprise deployments this is a
cheap, high-leverage reliability change, because it usually requires only editing the exception
handler rather than restructuring the agent. Bounded in-tool retry for genuinely transient faults
is a reasonable complement, but it cannot help with data errors such as a missing order, and
hiding all failures from the model removes the information it needs to choose between
recovery strategies.
KEY TAKEAWAYS
? Tool results are the agent's only feedback channel, so error text must be actionable
? Distinguish permanent data errors from transient infrastructure errors in the message itself
? Suggest the concrete next tool or action Claude should try
? Keep is_error true so the model does not mistake failure text for valid data
Question # 2
A customer sends: “This is frustrating. I’ve explained my issue twice and nothing is beingresolved. I want to talk to a real person NOW.” The agent has not yet called any tools toinvestigate the customer’s account. What should the agent do?
A. Briefly explain what the agent can help with and offer to resolve the issue quickly,escalating only if the customer repeats the request. B. First call get_customer and lookup_order to gather account context, and then escalate to ahuman agent. C. Immediately call escalate_to_human with the conversation history. D. Acknowledge the frustration and ask one targeted question to understand the specificissue before escalating.
Answer: C EXPERT VERIFICATION The original answer was correct. The original answer was correct.
EXPLANATION
Well-designed support agents treat an explicit, unambiguous request for a human as a hard
escalation trigger, not as an objection to be handled. The signals here are unmistakable and
compounding: the customer states frustration, reports having already explained the issue
twice, and demands a real person immediately. Calling escalate_to_human right away with the
full conversation history is both the respectful action and the operationally correct one,
because passing the transcript gives the human agent the context needed for a warm handoff
so the customer is not asked to explain a third time. This is where the first-contact-resolution
target must be understood correctly: FCR is a design goal, not a licence to obstruct. Optimizing
a metric by making escalation harder converts a satisfaction target into a satisfaction risk,
produces exactly the deflection loops customers hate, and in regulated industries can create
real complaint-handling exposure. It is also why escalate_to_human is provisioned as a first
class tool alongside the diagnostic tools- knowing when to stop is part of the agent's job. A
common misconception is that gathering account context first always improves the handoff.
Investigative tool calls are appropriate when the customer's intent is ambiguous, but here they
insert delay and further agent turns after an explicit demand, and the human agent has the
same backend systems available anyway. Similarly, acknowledging frustration and asking one
more targeted question sounds empathetic but reads as another deflection to a customer who
has already explained twice. KEY TAKEAWAYS
? Anexplicit, unambiguous request for a human is a hard escalation trigger.
? Pass the full conversation history so the human can perform a warm handoff.
? FCR targets must never be met by making escalation harder for the customer.
? Investigative tool calls belong before ambiguous requests, not after an explicit demand.
Question # 3
You are building a customer support resolution agent using the Claude Agent SDK. The agenthandles high-ambiguity requests like returns, billing disputes, and account issues. It hasaccess to your backend systems through custom Model Context Protocol (MCP) tools(get_customer, lookup_order, process_refund, escalate_to_human). Your target is 80%+ firstcontact 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?
A. Build a rules engine that maps specific issue types, customer segments, and productcategories to escalation decisions, removing the need for model judgment calls. B. Instruct the agent to escalate when the customer requests a human, when the issuerequires policy exceptions, or when the agent cannot make meaningful progress. C. Configure the agent to escalate after three consecutive tool calls that fail to resolve thecustomer’s stated issue, ensuring a reasonable attempt before involving a human. D. Implement sentiment analysis that monitors for frustration indicators (negative language,repeated questions, exclamation marks) and triggers escalation when the frustration scoreexceeds a configured threshold.
Answer: B EXPERT VERIFICATION The original answer was correct.
The original answer was correct; principle-based escalation criteria that the model applies with
judgement generalize across the open-ended situations a support agent actually meets.
EXPLANATION
Escalation is a judgement problem, and the question stem says so explicitly by describing
high-ambiguity requests such as returns, billing disputes, and account issues. The three
conditions in the correct option are the ones that genuinely mark a case as needing a person:
an explicit customer request for a human, which should always be honoured for trust reasons;
a situation requiring an exception to policy, which the agent has no authority to grant; and a
lack of meaningful progress, which is the general form of every stuck state rather than one
particular signature of being stuck. Expressing these as principles in the system prompt lets
the model recognize novel variants that no rule author anticipated, and pairing them with a
small number of concrete worked examples in the prompt sharpens calibration without
narrowing coverage. The alternatives each substitute a proxy for the underlying judgement. A
deterministic rules engine on issue type and customer segment cannot see whether this
particular conversation is going well. A fixed count of failed tool calls conflates normal multi
step investigation with genuine deadlock and both over-escalates and under-escalates.
Sentiment thresholds detect emotion, which correlates only loosely with whether human
authority is actually required, and they penalize expressive customers while missing calm but
genuinely blocked ones. In production, the right architecture keeps the model's judgement as
the primary trigger, adds a hard rule only for a narrow set of legally or financially mandated
cases, and instruments escalation outcomes so the criteria can be tuned against real first
contact-resolution data. A common misconception is that determinism is always safer; here it
mainly shifts the failure mode from missed escalations to wrong ones. KEY TAKEAWAYS ? Use principle-based criteria for judgement tasks and deterministic rules only for mandated
cases
? Always escalate on explicit human request, policy exceptions, and lack of meaningful
progress
? Failure counts and sentiment scores are proxies that both over- and under-trigger
? Measure escalation precision and recall against resolution outcomes and refine the criteria
Question # 4
You are building a customer support resolution agent using the Claude Agent SDK. The agenthandles high-ambiguity requests like returns, billing disputes, and account issues. It hasaccess to your backend systems through custom Model Context Protocol (MCP) tools(get_customer, lookup_order, process_refund, escalate_to_human). Your target is 80%+ firstcontact resolution while knowing when to escalate.When the agent calls lookup_order and receives order details showing the item was purchased45 days ago, how does the agentic loop determine whether to call process_refund orescalate_to_human next?
A. The order details are added to the conversation and the model reasons about which actionto take. B. The orchestration layer automatically routes to the next tool based on the order’s statusfield. C. The agent follows a pre-configured decision tree mapping order attributes to specific toolcalls. D. The agent executes the remaining steps in a tool sequence planned at the start of therequest.
Answer: A EXPERT VERIFICATION The original answer was correct.
The original answer was correct: this is a plain description of the agentic loop, where tool
results re-enter the conversation, and the model decides the next action.
EXPLANATION
In the Messages API and the Claude Agent SDK, agentic behaviour emerges from a simple
repeated cycle rather than from any planner or router. The model emits a tool_use block, your
code executes lookup_order, and the result is appended to the conversation as a tool_result
content block in a user-role message. The full conversation- system prompt with its policies,
the customer's request, prior tool calls, and now the order details showing a 45-day-old
purchase- is sent back to the model, which reasons over that accumulated state and either
produces text for the customer or emits the next tool_use, such as process_refund or
escalate_to_human. Nothing outside the model chooses; the orchestration layer only executes
tools and relays results. This is what gives agents their value on high-ambiguity work like
billing disputes and returns, because the model can weigh factors no static decision tree
anticipated- purchase date against the stated return window, item condition, customer
history, promotional terms- and can ask a clarifying question when the situation is genuinely
underdetermined. It also explains where control actually lives: because the model decides, the
levers that shape behaviour are the system prompt, the clarity of tool descriptions and their
result payloads, and deterministic guardrails such as hooks for the rules that must never be
left to judgement. A frequent misconception is that agent frameworks contain hidden routing
logic; they do not, and understanding that the loop is model-driven is what makes both prompt
design and hook-based enforcement make sense.
KEY TAKEAWAYS
? Tool results return as tool_result blocks and the model chooses the next action.
? The orchestration layer executes tools; it does not route or plan.
? Model-driven control is what handles ambiguity that no decision tree anticipates.
? Shape behaviour through system prompt, tool descriptions, and deterministic hooks.
Question # 5
You are building a customer support resolution agent using the Claude Agent SDK. The agenthandles high-ambiguity requests like returns, billing disputes, and account issues. It hasaccess to your backend systems through custom Model Context Protocol (MCP) tools(get_customer, lookup_order, process_refund, escalate_to_human). Your target is 80%+ firstcontact resolution while knowing when to escalate.Production logs show that when the agent handles complex billing disputes requiring 6+ toolcalls, it sometimes exhausts its max_turns limit after gathering data but before completingresolution or escalating. The team’s goal is to guarantee that every customer interaction endswith either a completed resolution or a human handoff, regardless of how the agent loopterminates.Which approach achieves this guarantee?
A. Implement a pre-tool-use hook that counts tool invocations and terminates the loop withan automatic escalation once the agent reaches 80% of its max_turns limit. B. Split the workflow into two sequential agent invocations—a first agent gathers informationvia get_customer and lookup_order, then a second agent receives that data and handlesprocess_refund or escalate_to_human, each with separate turn budgets. C. Addorchestration-layer code that checks the agent’s outcome after each looptermination—if the loop ended without a completed resolution or escalation,programmatically call escalate_to_human with the accumulated conversation context andtool results. D. Addsystem prompt instructions telling the agent to call escalate_to_human with asummary of its findings whenever it determines it cannot complete resolution within itsremaining actions.
Answer: C
EXPERT VERIFICATION The original answer was correct.
The original answer was correct: only an orchestration-layer check after loop termination covers
every way the loop can end, including turn exhaustion, errors, and timeouts.
EXPLANATION
The requirement is a guarantee about the terminal state of every interaction, regardless of
how the agent loop ends, so the enforcement point must sit outside the loop. Wrapping the
agent in orchestration code that inspects the final result and asks a simple question- did thi
run finish with either a completed resolution or a human escalation- and, if not,
programmatically calls escalate_to_human with the accumulated conversation and tool results,
closes every path at once: max_turns exhaustion, an unhandled tool error, a model refusal, a
network failure, or a process timeout. It is the classic finally block of agent design, and it
degrades gracefully because the escalation carries everything the agent already gathered, so
the human starts with the customer record, order history, and dispute details rather than from
zero. Implementation notes: define completion as a machine-detectable signal such as a
successful process_refund result or a recorded escalation ticket, rather than trying to infer it
from the model's prose; make the fallback escalation idempotent so a retry does not create
duplicate tickets; and emit metrics on how often the fallback fires, since a rising rate is the
early warning that turn budgets or tool design need attention. In-loop mitigations such as
raising max_turns, splitting the workflow, or prompting the agent to escalate when it senses it
is running out of room are all useful for reducing how often the fallback triggers, but each still
assumes the loop reaches a point where it can act, which is precisely the assumption a
guarantee cannot make.
KEY TAKEAWAYS
? Guarantees about terminal state must be enforced outside the agent loop.
? An orchestration-layer post-check covers turn exhaustion, errors, and crashes uniformly.
? Pass accumulated context into the fallback escalation so humans do not restart from zero.
? Track fallback frequency as a health metric for turn budgets and tool design.
Question # 6
You are building a customer support resolution agent using the Claude Agent SDK. The agenthandles high-ambiguity requests like returns, billing disputes, and account issues. It hasaccess to your backend systems through custom Model Context Protocol (MCP) tools(get_customer, lookup_order, process_refund, escalate_to_human). Your target is 80%+ firstcontact resolution while knowing when to escalate.Compliance requires that refunds exceeding $500 must automatically escalate to a humanagent—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% failurerate).How should you achieve guaranteed compliance?
A. Addfew-shot examples to the prompt showing correct escalation behavior at variousrefund 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.
Answer: D EXPERT VERIFICATION The original answer was correct.
The original answer was correct: a PreTool Use hook is deterministic code outside the model's
discretion and it both blocks the refund and triggers escalation.
EXPLANATION
Any policy described as must and cannot be left to model discretion has to be enforced in
code, not in the prompt. Prompts shape probability, they do not create guarantees, which is
exactly why the emphatic instruction still leaves a 3% violation rate. The Claude Agent SDK
provides hooks for this: a PreToolUse hook runs deterministically before every tool invocation,
receives the tool name and the exact input arguments, and can allow, modify, or deny the call.
Here the hook inspects process_refund, parses the amount, and when it exceeds 500 returns a
deny decision while invoking escalate_to_human and feeding a clear explanation back into the
conversation so the agent narrates the handoff to the customer rather than getting stuck. The
refund can then never execute regardless of how the model was prompted, jailbroken, or
confused, and the hook is a single auditable chokepoint that logs every attempt- which is what
compliance and audit teams actually need. Design guidance is to keep the model's instructions
in place as a first line of defence so the agent usually escalates on its own and the hook is only
a backstop, and to keep hook logic simple, fast, and fully deterministic. In production you
normally layer this with a server-side check in the refund service itself, since defence in depth
means the backend refuses out-of-policy amounts even if a caller bypasses the agent entirely.
The misconception worth naming is that stronger wording, capital letters, or more few-shot
examples can turn a probabilistic behaviour into a guarantee.
KEY TAKEAWAYS
? Hard policy limits belong in deterministic code, never in prompt wording.
? PreTool Use hooks inspect tool inputs and can block or redirect the call.
? Have the hook both deny the action and trigger the compliant alternative.
? Keep prompt guidance as a first line and add server-side enforcement for defence in depth.
Question # 7
You are building a customer support resolution agent using the Claude Agent SDK. The agenthandles high-ambiguity requests like returns, billing disputes, and account issues. It hasaccess to your backend systems through custom Model Context Protocol (MCP) tools(get_customer, lookup_order, process_refund, escalate_to_human). Your target is 80%+ firstcontact resolution while knowing when to escalate.During a billing dispute resolution, your agent successfully retrieves customer info viaget_customer and order details via lookup_order, but when attempting to call process_refund,the tool returns a timeout error. The agent has enough information to explain the charges andverify refund eligibility, but cannot actually process the refund due to the backend failure.What approach best balances first-contact resolution with appropriate error handling?
A. Implement automatic retries with exponential backoff for process_refund, keeping theconversation open until the refund is successfully processed. B. Confirm the refund will be processed and close the conversation, since the system has allnecessary information to complete it automatically. C. Explain the billing, confirm refund eligibility, acknowledge the system issue preventingimmediate processing, and offer escalation or retry later. D. Escalate immediately to a human agent since the refund action cannot be completed.
Answer: C EXPERT VERIFICATION The original answer was correct.
The original answer was correct: the agent should deliver all the value it can, be transparent
about the backend failure, and offer the customer a choice, which is the graceful-degradation
pattern.
EXPLANATION
Designing customer support agents means planning for partial failure, because backend
systems will time out and an agent that has no defined behaviour for that case will either
fabricate success or abandon a mostly solvable interaction. Here the agent has already
accomplished the hard, ambiguity-resolving work: it identified the customer, retrieved the
order, can explain the disputed charges, and has confirmed refund eligibility. Only the final
mutating action failed. Graceful degradation means preserving everything that succeeded,
being explicit about the single thing that did not, and handing control back to the customer
with concrete next steps, in this case escalation to a human via escalate_to_human or a
scheduled retry with a follow-up commitment. This maximises resolution value without
crossing the two lines that damage trust: it never asserts that a refund was processed when
the call actually failed, and it does not discard a nearly complete interaction by escalating the
moment anything goes wrong. Two design details matter in implementation. First, a timeout is
ambiguous, because the refund may or may not have been committed on the backend, so
blind automatic retries risk duplicate refunds unless the tool is idempotent with a client
supplied idempotency key. Second, honesty about system state is a Constitutional AI aligned
behaviour and a compliance requirement in financial contexts. The right escalation policy is
capability-based rather than error-based: escalate when the agent lacks authority, information,
or a working path forward, not merely because one tool call returned an error.
KEY TAKEAWAYS
? Design explicit degraded-mode behaviour for tool failures rather than leaving it to the
model.
? Deliver all value already obtained, disclose the failure honestly, and offer the customer a
choice.
? Never confirm a mutating action that did not verifiably succeed; timeouts leave state
ambiguous.
? Make refund-style tools idempotent before adding automatic retries, and escalate on
capability limits.
Question # 8
You are building a customer support resolution agent using the Claude Agent SDK. The agenthandles high-ambiguity requests like returns, billing disputes, and account issues. It hasaccess to your backend systems through custom Model Context Protocol (MCP) tools(get_customer, lookup_order, process_refund, escalate_to_human). Your target is 80%+ firstcontact resolution while knowing when to escalate.Your agent is handling a billing dispute. After calling get_customer and lookup_order, itidentifies that the dispute involves a promotional pricing error requiring manager approval—beyond the agent’s authorization level.How should the workflow handle this mid-process escalation?
A. Call escalate_to_human, passing only the customer’s original message. B. Compile a structured handoff with customer details, order info, and the identified issuebefore calling escalate_to_human. C. Attempt the refund with process_refund anyway, escalating only if the system rejects thetransaction. D. Persist the complete conversation and tool response history to a database, then callescalate_to_human with a reference ID.
Answer: B EXPERT VERIFICATION The original answer was correct.
The original answer was correct: a structured handoff payload passed to escalate_to_human is
the design that preserves the agent's work and minimises human re-work.
EXPLANATION
Escalation is a first-class part of agent design, not a failure path. By the time the agent
recognises that the promotional pricing error exceeds its authorisation level, it has already
spent tool calls establishing customer identity through get_customer and order facts through
lookup_order, and it has formed a diagnosis. Discarding that context and handing the manager
only the customer's original message forces a complete re-investigation and destroys the first
contact-resolution economics you were optimising for. The right pattern is for the
escalate_to_human tool to accept a structured payload: customer identifier and account
status, the specific order and line items in dispute, the diagnosed root cause, the actions the
agent already attempted, the reason escalation is required, and a recommended resolution.
Designing the MCP tool's input schema to require these fields is what makes the behaviour
reliable, because the schema itself forces the model to assemble the summary rather than
relying on prompt instructions alone. In enterprise support architectures this payload becomes
the ticket body in the CRM, so the human agent opens a case that is already triaged. Best
practice is to define clear authorisation boundaries in the system prompt, expose escalation as
an explicit tool rather than an error condition, and measure escalation quality as well as
escalation rate. A common misconception is that escalating early signals a weak agent; a well
scoped escalation with a good handoff is a successful outcome, whereas an agent attempting
an unauthorised refund is a compliance incident. KEY TAKEAWAYS
? Treat escalation as a designed capability with a rich, schema-enforced handoff payload, not
a bare fallback.
? Encode required handoff fields in the MCP tool input schema so the model must assemble
them.
? Preserve investigative work: customer, order, diagnosis, attempted actions, and
recommended resolution.
? Define authorisation boundaries explicitly so the agent never attempts actions beyond its
permitted scope.
Question # 9
You are building developer-productivity tools using the Claude Agent SDK. The agent helpsengineers explore unfamiliar codebases, understand legacy systems, generate boilerplatecode, and automate repetitive tasks. It uses the built-in tools—Read, Write, Bash, Grep, andGlob—and integrates with Model Context Protocol (MCP) servers.You are building a security-scanning workflow.When engineers need to locate every occurrence of a dangerous function such as eval() acrossa large codebase, which tool should the agent use for content searching?
A. UseGlob with a pattern such as **/eval* to locate files, and then read each matching file. B. Use grep to search for the regular-expression pattern eval\( across all files in thecodebase. C. Read the project’s main entry file and follow import statements to trace where eval()might be used. D. Use Bash to run ls-R | grep eval and search the recursively listed filenames.
Answer: B EXPERT VERIFICATION The original answer was correct.
The original answer was correct: Grep is the purpose-built content-search tool and is the right
choice for finding eval occurrences.
EXPLANATION
The Claude Agent SDK's built-in file tools have deliberately narrow, complementary jobs, and
choosing correctly is a meaningful performance and reliability decision on a large repository.
Glob matches file paths by pattern and answers "which files exist with names like this". Grep is
built on ripgrep and searches file contents by regular expression, answering "which files and
lines contain this pattern", with filters for file type and include globs and modes that return file
paths, matching lines with context, or counts. Read pulls a specific file, or a range of lines
within it, into context. For a security scan that must locate every call site of a dangerous
function, the question is purely about content, so Grep with a pattern such as eval\( is correct,
and the escaped parenthesis matters because the parenthesis is a regex metacharacter. Grep
is fast across very large trees, returns only matches rather than whole files, and therefore
keeps the agent's context small, which directly improves both cost and answer quality. Good
practice is to follow up with a targeted Read on the specific files and line ranges Grep reports,
so the agent examines each call site in context and can distinguish a real eval() invocation
from a comment, a string literal, or a variable named evaluate. The misconception to avoid is
reaching for Bash with ad hoc shell pipelines; that searches filenames rather than content
the ls case, is platform dependent, and bypasses the tooling and permission model the SDK
provides.
KEY TAKEAWAYS
? Grep searches file contents; Glob matches file paths; Read pulls specific files into context
? Escape regex metacharacters, for example eval\( when searching for a call
? Grep returns only matches, keeping agent context small and cheap
? Follow content search with targeted reads to confirm each call site in context
Question # 10
Your automated reviewer uses a single prompt covering security issues, API design, andbusiness-logic correctness. Your evaluation suite shows strong recall for API-design findings at82% but poor recall for business-logic edge cases in quiz scoring at 34%. When you add fewshot examples of logic bugs to the prompt, logic recall improves to 41%, but API-design recalldrops to 68%. How should you address this trade-off to improve detection across bothcategories?
A. Provide the full repository as context instead of only the changed files and surroundingcode, giving the model deeper visibility into business-logic patterns. B. Replace the few-shot examples with a detailed checklist of specific logic edge cases toverify, such as division by zero in score calculations and boundary conditions in gradingthresholds. C. Split the review into separate focused prompts—one for security and API design andanother for business logic—each with dedicated examples, and then consolidate thefindings before posting. D. Upgrade to a more capable model tier because its stronger reasoning will handle bothconcern types in a single prompt and eliminate the recall trade-off.
Answer: C EXPERT VERIFICATION The original answer was correct.
EXPLANATION
The evidence in the question is the giveaway: adding logic examples raised logic recall from 34
to 41 percent but dropped API recall from 82 to 68 percent. That inverse movement is the
signature of attention competition inside a single prompt- a fixed budget of instruction
following capacity is being reallocated, not expanded. When one prompt must simultaneously
hold security heuristics, API design conventions, and domain-specific business rules about quiz
scoring, emphasizing any one concern necessarily de-emphasizes the others. The architectural
remedy is decomposition: run separate, focused review passes, each with its own system
prompt, its own few-shot examples, and its own output schema, then merge and deduplicate
findings before posting a single consolidated comment to the pull request. Each pass now gets
the model's full attention on a narrow objective, and you can tune, evaluate, and version the
passes independently- measuring per-category recall without one change silently regressing
another. This is the same specialization principle behind subagents in the Claude Agent SDK
and behind prompt-chaining guidance in Anthropic's docs. Costs are real but modest and
controllable: multiple passes mean more input tokens, which prompt caching on the shared diff
largely absorbs, and the passes can run concurrently so wall-clock latency barely moves. Note
also that the business-logic gap is domain knowledge- the model does not know your grading
thresholds- and no larger model tier magically supplies it; a checklist helps but leaves the
same single-prompt competition in place, only with different content. KEY TAKEAWAYS
? Recall trading inversely between categories signals attention competition in one prompt.
? Split into focused passes with dedicated examples, then consolidate findings before posting.
? Independent passes can be evaluated and tuned per category without cross-regression.
? Prompt caching and parallel execution keep multi-pass review affordable and fast.
Question # 11
You are integrating Claude Code into your Continuous Integration/Continuous Deployment(CI/CD) pipeline. The system runs automated code reviews, generates test cases, and providesfeedback on pull requests. You need to design prompts that provide actionable feedback andminimize false positives.The automated review consistently flags patterns your team uses intentionally—forceunwrapping optionals in test files, using large coordinator classes that follow your establishedarchitecture, and importing internally maintained modules marked as deprecated in the publicSDK. Developers dismiss approximately 30% of all findings as project-specific false positives.Which approach prevents the model from generating these findings in the first place bysupplying the project’s conventions as persistent context during every review?
A. Document the team’s accepted patterns and intentional conventions in the project’sCLAUDE.md file so the model receives this context during every review. B. Configure the review to analyze only the changed lines in the diff without the surroundingfile context, reducing the amount of code the model evaluates. C. Build post-processing keyword filters that suppress findings containing terms such as“force unwrap,” “large class,” or “deprecated import” before results reach developers. D. Havedevelopers add inline suppression comments at flagged lines and preprocess diffs toexclude suppressed lines before sending code to the model.
Answer: A EXPERT VERIFICATION The original answer was correct.
The original answer was correct; CLAUDE.md is the documented mechanism for supplying
persistent project context to every Claude Code invocation, which is exactly what the question
asks for.
EXPLANATION
A thirty percent false-positive rate is the classic symptom of a reviewer that lacks project
context rather than one that lacks capability. Force-unwrapping in tests, large coordinator
classes, and imports of internally maintained modules are all genuinely suspicious in the
abstract; they are only acceptable because this team has decided they are. CLAUDE.md is the
file Claude Code loads automatically at the start of every session in a project, and it is
designed to carry exactly this kind of durable, repository-specific knowledge: architecture
decisions, naming conventions, patterns that look wrong but are intentional, and things that
are handled elsewhere in the toolchain. Because it is loaded before the model reasons about
the diff, it changes what findings are generated rather than filtering them afterwards, which is
what the question stem specifically requires. It also lives in version control, so the conventions
are reviewed, evolve with the codebase, and apply identically to local sessions and CI runs. In
practice the most effective entries are short, concrete, and explain the rationale, for example
stating that test targets deliberately force-unwrap because a nil value should fail the test
loudly. Teams should treat the file as a living artifact and add an entry each time a false
positive is dismissed, which drives the noise rate down over successive releases. A common
misconception is that keyword suppression achieves the same outcome; filtering strings after
the fact discards genuine findings that happen to use the same vocabulary and does nothing
to stop the model wasting reasoning on patterns it should never have flagged.
KEY TAKEAWAYS
? CLAUDE.md is auto-loaded project context and shapes findings before they are generated
? Post-hoc keyword filters suppress real bugs that share vocabulary with false positives
? Record the rationale for intentional patterns, not just the pattern itself
? Feed dismissed false positives back into CLAUDE.md so review noise declines over time
Question # 12
After deploying the automated review, you notice high precision but low recall—real bugs areslipping through undetected. Investigation reveals that your review prompt instructs Claude to“only report high-confidence issues you are certain about” and “err on the side of notcommenting.” Developers appreciate the low noise, but a race condition that caused aproduction outage was visible in a reviewed pull request and went unreported. You need tosubstantially improve bug detection while keeping false-positive rates manageable. What isthe most effective approach?
A. Adddetailed few-shot examples demonstrating bug categories Claude should flag—raceconditions, null dereferences, and error-handling gaps—while retaining the high-confidencefiltering instruction. B. Remove the conservative instructions and have Claude report every potential issue, thenapply a programmatic filter that deduplicates findings and suppresses historically noisycategories. C. Split the review into a finding stage whose objective is comprehensive coverage—reporting every potential issue with confidence and severity metadata—and a separatestage that verifies and thresholds those findings. D. Expand the context to include related tests, recent Git history, and the module’sdependency graph so Claude has richer evidence for judging severity.
Answer: C
EXPERT VERIFICATION The original answer was correct.
The original answer was correct: only option C changes the structural trade-off between
precision and recall rather than tuning a single conflicted prompt.
EXPLANATION
The core problem is that one prompt is being asked to do two contradictory jobs at once- find
everything, and only speak when certain. Whenever a single model call carries both a recall
objective and a precision objective, the more restrictive instruction dominates, which is exactly
why the review has high precision and misses a visible race condition. The architectural fix is
to decompose the task into stages with separate, non-conflicting objectives. A finding stage is
instructed to be exhaustive, emitting every candidate issue along with structured metadata
such as confidence, severity, category, and the specific lines of evidence. A second verification
stage then receives each candidate independently and acts as a skeptical reviewer, confirming
or rejecting it against the code, after which a deterministic threshold decides what is actually
posted to the pull request. This is the same generate-then-verify pattern Anthropic uses in its
own code review and security review tooling, and it works because verification is a much
easier, better-bounded judgement than open-ended discovery. It also gives you two
independent tuning knobs: you raise recall by loosening the finder and control noise by
tightening the verifier or the posting threshold, without regressing the other. Operationally, the
metadata makes the pipeline measurable- you can track detected-but-suppressed issues,
compute recall against a labelled bug set, and adjust thresholds per repository or per severity.
A common misconception is that better prompting alone can resolve the tension; in practice,
telling one call to be both comprehensive and conservative reliably collapses toward silence. KEY TAKEAWAYS
? Precision and recall objectives conflict inside a single prompt; separate them into distinct
stages.
? Have the finder emit confidence and severity metadata so filtering becomes deterministic
and tunable.
? Generate-then-verify is the standard pattern for automated code review at scale.
? Structured findings make recall measurable rather than invisible.
Question # 13
You are integrating Claude Code into your Continuous Integration/Continuous Deployment(CI/CD) pipeline. The system runs automated code reviews, generates test cases, and providesfeedback on pull requests. You need to design prompts that provide actionable feedback andminimize false positives.After deploying automated code review, developers report that approximately 35% of findingsare false positives following consistent patterns: style suggestions that contradict teamconventions, security warnings for patterns that are safe in the deployment environment, andperformance suggestions that would degrade this particular use case.You want to reduce false positives while enabling the model to generalize its judgment tonovel code patterns it has not seen before.Which approach is most effective?
A. Create a comprehensive specification of every pattern that must not be flagged andinclude the complete document in the system prompt. B. Include few-shot examples containing annotated code snippets that distinguish acceptableproject patterns from genuine issues in each category. C. Usekeyword-based post-processing to remove findings containing terms such as“convention,” “context-dependent,” or “trade-off.” D. Addgeneral instructions telling Claude to be conservative and report only definite issues.
Answer: B EXPERT VERIFICATION The original answer was correct.
The original answer was correct: the requirement to generalise to unseen code patterns is what
selects few-shot examples over an exhaustive enumeration of forbidden findings.
EXPLANATION
The scenario has two constraints that must both be satisfied: cut a thirty-five percent false
positive rate, and have the model apply the same judgement to novel code it has not
encountered. Few-shot examples satisfy both because they teach the underlying decision
boundary rather than a lookup table. By showing annotated pairs in each problem category, for
instance a formatting choice that matches team convention next to a genuine readability
defect, a pattern that is safe because of a deployment-environment guarantee next to a real
injection risk, and an optimisation that would hurt this workload next to a true performance
bug, you give Claude the reasoning principles behind your team's standards. The model then
extrapolates those principles to code it has never seen, which is exactly the generalisation an
exhaustive specification cannot provide, since any enumeration covers only listed patterns,
grows without bound, consumes a large stable prefix of the prompt, and goes stale as the
codebase evolves. Implementation notes matter in practice: keep the example set small and
high-contrast, draw the examples from real dismissed findings so they reflect your actual
disagreements, place them in the stable portion of the prompt and use prompt caching so the
added tokens are inexpensive across many pull requests, and maintain a labelled eval set to
confirm that false positives fall without suppressing true positives. Vague instructions to be
conservative typically trade false positives for missed defects, and keyword filtering on output
text is brittle and can delete valid findings, so neither addresses calibration. KEY TAKEAWAYS
? Few-shot examples teach a decision boundary that generalises to unseen patterns.
? Contrast pairs, acceptable versus genuine issue, are more instructive than one-sided
examples.
? Source examples from real dismissed findings and cache the stable prompt prefix.
? Track false positives and true positives together so noise reduction does not hide real bugs.
Question # 14
You are integrating Claude Code into your Continuous Integration/Continuous Deployment(CI/CD) pipeline. The system runs automated code reviews, generates test cases, and providesfeedback on pull requests. You need to design prompts that provide actionable feedback andminimize false positives.Your pipeline reviews every pull request using a single API call with a static prompt containingthe diff and the full text of each changed file. Unchanged files are not included. Developersreport that reviews consistently miss cross-file bugs—for example, a pull request renames afunction’s parameters, but the review does not identify callers in unchanged files that still usethe old argument order.Evaluation shows that cross-file bugs account for 35% of production incidents originating fromreviewed pull requests.What is the most effective change to the review design?
A. Build a static dependency graph and include every file located within two dependencyhops of a changed file. B. Add instructions asking the model to list external references and reason step by stepabout how each change could affect unseen callers. C. Redesign the review as a turn-limited agentic task that can read files and search therepository, following references to verify cross-file findings. D. Runseparate review passes for each changed file with its direct dependants, and thenaggregate and deduplicate the findings through a final consolidation pass.
Answer: C EXPERT VERIFICATION The original answer was correct.
The original answer was correct: the review fails because it is a single static call that cannot see
unchanged callers, and only an agentic review that can search and read the repository resolves
that structurally. EXPLANATION
The root cause is that the review's context is fixed at request-construction time and
deliberately excludes unchanged files, yet cross-file bugs by definition live in unchanged files.
No prompt improvement can conjure code the model was never shown. Converting the review
into a bounded agentic task changes the information model: Claude receives the diff plus tools
such as Grep, Glob, and Read, and can act on what it discovers, searching for every call site of
the renamed function, opening those files, and confirming whether the argument order
actually breaks. This is exactly the workload Claude Code is designed for, and running it in CI
through the GitHub Action or the Agent SDK is a standard enterprise pattern. Two design
constraints keep it practical. Turn limits and a token budget bound cost and latency, which
matters because agentic reviews are more expensive than one static call. Requiring the model
to verify each cross-file finding by citing the specific file and line it read sharply reduces false
positives, since the model must ground the claim in retrieved evidence rather than speculate.
Prompt caching over the stable system prompt and review instructions further reduces cost
across many pull requests. The economics are compelling here because cross-file defects
account for thirty-five percent of production incidents from reviewed pull requests, so the
marginal cost per review is small relative to the incidents avoided. The common misconception
is that telling the model to reason step by step about unseen callers helps; reasoning without
retrieval produces confident guesses, not verified findings. KEY TAKEAWAYS ? Static single-call reviews cannot detect defects in files that were never placed in context.
? Agentic review with Read, Grep, and Glob lets Claude follow references and verify findings.
? Bound agentic reviews with turn limits and token budgets, and cache the stable prompt
prefix.
? Requiring cited file and line evidence for each finding is the main lever against false
positives.
Question # 15
The automated review consistently flags patterns your team uses intentionally—forceunwrapping optionals in test files, using large coordinator classes that follow your establishedarchitecture, and importing internally maintained modules marked as deprecated in the publicSDK. Developers are dismissing approximately 30% of all findings as project-specific falsepositives. Which approach prevents the model from generating these findings in the first placeby supplying the project’s conventions as persistent context during every review?
A. Build post-processing keyword filters that suppress findings containing terms such as“force unwrap,” “large class,” or “deprecated import” before results reach developers. B. Configure the review to analyze only the changed lines in the diff without surrounding filecontext, reducing the amount of code the model evaluates during each review. C. Have developers add inline suppression comments at flagged lines and preprocess diffs toexclude suppressed lines before sending code to the model. D. Document the team’s accepted patterns and intentional conventions in the project’sCLAUDE.md file so the model receives this context during every review.
Answer: D EXPERT VERIFICATION The original answer was correct.
The original answer was correct: the question asks specifically for persistent context supplied
during every review, which is the defining role of CLAUDE.md.
EXPLANATION
The false positives here are not model errors in the abstract; each flagged pattern would be a
legitimate finding in a generic codebase and is only acceptable because of decisions this team
has made deliberately. Force-unwrapping in test files, large coordinator classes mandated by
the established architecture, and imports of internally maintained modules that the public SDK
marks deprecated are all project knowledge that the model has no way to infer from a diff.
CLAUDE.md is the mechanism for supplying exactly that knowledge, because Claude Code
loads it automatically for every session in the repository, making it persistent, version
controlled, reviewable, and shared across the whole team rather than living in one engineer's
ad-hoc prompt. Documenting each accepted pattern together with a short rationale and its
scope, for example noting that force-unwrapping is acceptable in test targets but not in
production code, prevents the findings from being generated at all, which is what the question
asks for and which is strictly better than suppressing them after the fact. Practical guidance:
keep entries concrete and brief since the file consumes context on every run, use directory
scoped CLAUDE.md files for module-specific conventions, review the file through normal pull
request process, and revisit it as conventions change so it does not silently mask patterns that
are no longer acceptable. A common misconception is that keyword-based post-filters achieve
the same outcome; they operate on finding text rather than intent, so they inevitably suppress
genuine defects that happen to use the same vocabulary while doing nothing to improve the
model's judgement. KEY TAKEAWAYS
? CLAUDE.md supplies persistent, automatically loaded project context on every Claude Code
review.
? Document intentional conventions with rationale and scope so findings are never generated,
not merely filtered.
? Version-controlled project memory is shared and reviewable, unlike ad-hoc per-developer
prompts.
? Keyword post-filters match text rather than intent and will suppress genuine defects along
