Getting ready for the Anthropic CCAR-F certification exam can feel challenging, but with the right preparation, success is closer than you think. At PASS4EXAMS, we provide authentic, verified, and updated study materials designed to help you pass confidently on your first attempt.
Why Choose PASS4EXAMS for Anthropic CCAR-F?
At PASS4EXAMS, we focus on real results. Our exam preparation materials are carefully developed to match the latest exam structure and objectives.
Real Exam-Based Questions – Practice with content that reflects the actual Anthropic CCAR-F exam pattern.
Updated Regularly – Stay current with the most recent CCAR-F syllabus and vendor updates.
Verified by Experts – Every question is reviewed by certified professionals for accuracy and quality.
Instant Access – Download your materials immediately after purchase and start preparing right away.
100% Pass Guarantee – If you prepare with PASS4EXAMS, your success is fully guaranteed.
What’s Inside the Anthropic CCAR-F Study Material
When you choose PASS4EXAMS, you get a complete and reliable preparation experience:
Comprehensive Question & Answer Sets that cover all exam objectives.
Practice Tests that simulate the real exam environment.
Detailed Explanations to strengthen understanding of each concept.
Free 3 months Updates ensuring your material stays relevant.
Expert Preparation Tips to help you study efficiently and effectively.
Why Get Certified?
Earning your Anthropic CCAR-F certification demonstrates your professional competence, validates your technical skills, and enhances your career opportunities. It’s a globally recognized credential that helps you stand out in the competitive IT industry.
Anthropic CCAR-F Sample Question Answers
Question # 1
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.
