exam-a · Q1Multi-agent research

The synthesis agent receives summarized findings from the web search and document analysis agents, then passes a consolidated summary to the report generator. During testing, you discover the generated reports make factual claims without proper citations – the report generator cannot attribute statements to their original sources because that metadata was lost during the summarization steps. What’s the most effective approach to ensure proper source attribution in the final reports?

1. AHave the report generator query the web search agent to re-locate sources for claims in the final report.
2. BHave each agent output structured data separating content summaries from source metadata (URLs, document names, page numbers).
3. CSkip summarization and pass full raw outputs from web search and document analysis directly to the report generator.
4. DInstruct the synthesis agent to embed source references inline within its summary text using a consistent citation format.

community agreesWhy

exam-a · Q2Multi-agent research

After the web search agent finds 25 sources (120K tokens of raw content), the document analysis agent extracts key insights (15K tokens), and the synthesis agent produces a coherent narrative draft (3K tokens), the coordinator must pass context to the report generation agent for the final output with proper source citations. What context-passing strategy provides the best balance of completeness and efficiency?

1. APass the full accumulated context from all prior agents.
2. BPass the synthesis draft along with a structured source index that maps key claims to their source URLs and relevant excerpts.
3. CPass only the synthesis draft and have a separate post-processing pipeline match claims to sources and insert citations after the report is generated.
4. DPass a condensed summary of all prior stages that preserves the main findings and attributes them to sources by name only.

nobody has checked this keyWhy

exam-a · Q3Multi-agent research

Your multi-agent research pipeline crashed after processing12 of 28 documents. The web search agent had identified relevant sources, the document analyzer had partially completed extraction, and the synthesizer had begun pattern identification. You need to resume processing without repeating work or losing fidelity of prior findings. What state management approach best balances information fidelity with context efficiency when restoring agent state?

1. AHave each agent persist a structured export to a known location. On resume, the coordinator loads the manifest and injects relevant state into agent prompts.
2. BIndex all agent outputs in a shared vector store. When resuming, each agent queries the store using semantic search to retrieve relevant prior findings.
3. CHave each agent maintain its own persistent state file and reload it independently at the start of each session.
4. DPersist the coordinator’s conversation log containing all task delegations and responses, providing this to agents when resuming.

nobody has checked this keyWhy

exam-a · Q4Multi-agent research

You’ve configured the system so that all four subagents have access to the complete set of 18 tools. During testing, agents frequently call tools outside their specialization – the synthesis agent attempts web searches, and the report generator tries to analyze documents. What is the primary cause of this poor tool selection behavior?

1. AChoosing from 18 tools instead of 4-5 relevant ones increases decision complexity beyond reliable selection thresholds.
2. BThe tool definitions consume too much context window space, leaving insufficient room for task content.
3. CThe agents’ role descriptions in their system prompts conflict with having access to tools outside that role.
4. DThe coordinator cannot track which capabilities each subagent has, leading to misrouted tasks.

nobody has checked this keyWhy

exam-a · Q5

The coordinator provides detailed step-by-step instructions to the web search subagent, specifying exact search queries, source priorities, and date filters. Production monitoring reveals three issues: (1) the subagent reports “insufficient results” rather than trying alternative approaches when pre-specified searches fail, (2) research quality drops for emerging topics that don’t match expected patterns, and (3) the subagent rarely surfaces valuable tangential sources. What’s the most effective way to improve subagent adaptability?

1. AImplement a topic classification step where the coordinator categorizes requests as “well-defined” or “exploratory” and uses different instruction styles for each category.
2. BAdd explicit fallback directives to the detailed instructions: “If specified searches yield fewer than N results, attempt alternative query formulations before reporting failure.”
3. CRemove procedural details entirely, delegating with simple goals like “research X thoroughly” and relying on the subagent’s general capabilities.
4. DSpecify research goals and quality criteria (coverage breadth, source diversity, recency) rather than procedural steps, letting the subagent determine its search strategy.

nobody has checked this keyWhy

exam-a · Q6Multi-agent research

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

1. AHave the report generation agent note which research questions couldn’t be answered, so users understand the limitations of the final output.
2. BIncrease the initial breadth of queries sent to web search and document analysis to reduce the probability of missing relevant information.
3. CHave the coordinator evaluate synthesis output for gaps, then re-delegate to web search and document analysis with targeted queries before invoking synthesis again.
4. DGive the synthesis agent direct access to web search tools so it can autonomously fill knowledge gaps without returning control to the coordinator.

nobody has checked this keyWhy

exam-a · Q7Multi-agent research

The web search agent has gathered several relevant sources for a research topic. The document analysis agent now needs to examine these sources. How does information typically flow between these two specialized subagents?

1. AThe agents communicate through an event-driven message queue, with the document analysis agent subscribing to web search completion events.
2. BThe web search agent directly invokes the document analysis agent, passing the discovered sources as parameters.
3. CThe coordinator agent receives the web search agent’s output and includes relevant findings in the prompt when invoking the document analysis agent.
4. DBoth agents access a shared memory store where the web search agent writes findings and the document analysis agent reads them.

nobody has checked this keyWhy

exam-a · Q8Multi-agent research

Production reviews reveal inconsistent handling of uncertainty in final reports. Sometimes conflicting subagent findings are synthesized into a single confident statement (losing nuance), while other times reports over-hedge with excessive qualifications (becoming unhelpful). When the web search agent returns “industry analysts estimate $50B market size (methodology varies)” and the document analysis agent returns “peer- reviewed study estimates $35B (±$7B, 95% CI),” the coordinator either picks one arbitrarily or produces vague statements like “the market may be $35B-$50B depending on factors.” What systematic approach best addresses this?

1. AConfigure subagents to only report findings meeting a high-confidence threshold, filtering uncertain information before it reaches the coordinator.
2. BAdd a verification subagent that cross-references findings across sources, only passing claims to synthesis that are corroborated by at least two independent sources.
3. CInstruct the synthesis agent to structure reports with explicit sections distinguishing well-established findings from contested ones, preserving original source characterizations and methodological context.
4. DImplement a confidence calibration layer that normalizes subagent uncertainty expressions to standardized probability scores (0.0-1.0), then weight-average findings by their calibrated confidence.

community says DWhy

exam-a · Q9Multi-agent research

In production, final reports frequently contain claims without proper source attribution. Investigation shows that while the web search and document analysis agents correctly attach citations to their outputs, the synthesis agent loses track of which sources support which conclusions when combining findings. What’s the most effective architectural change?

1. ARequire all subagents to output structured claim-source mappings that the synthesis agent must preserve and merge when combining findings from multiple sources.
2. BMaintain complete transcripts of all subagent interactions and add a citation-resolution agent to analyze logs and determine attributions before report generation.
3. CAdd a verification step where the report generator uses semantic similarity matching against original sources to reconstruct which claims came from which documents.
4. DHave the coordinator inject source identifier prefixes into text before each handoff, then parse these prefixes at report generation to reconstruct citations.

nobody has checked this keyWhy

exam-a · Q10Multi-agent research

After the web search agent and document analysis agent complete their tasks, the coordinator invokes the synthesis agent. However, the synthesis agent responds that it cannot complete the task because no research findings were provided. What is the most likely cause of this issue?

1. AThe subagents need to share a single API connection to enable automatic context sharing between invocations.
2. BThe synthesis agent needs tools that can fetch results directly from the other agents’ conversation histories.
3. CThe coordinator did not include the outputs from the previous agents in the synthesis agent’s prompt.
4. DThe synthesis agent’s context window is not large enough to hold the combined outputs from both previous agents.

nobody has checked this keyWhy

exam-a · Q11Multi-agent research

Users report that final reports sometimes lack depth on specific subtopics. Investigation shows that the document analysis agent frequently identifies gaps – for instance, noting “the retrieved sources discuss API authentication but lack details on token refresh patterns” – but under the current strict pipeline, this insight isn’t actionable since search has already completed. What’s the most effective architectural change?

1. AAdd a research planning agent before the search phase that decomposes topics into specific sub-questions.
2. BHave the analysis agent report specific gaps to the coordinator, which triggers targeted searches and re-invokes analysis until sufficient.
3. CHave the coordinator review analysis output for gap indicators and re-invoke search with gap-informed queries when gaps are detected.
4. DHave the synthesis agent attach confidence scores to each section and flag areas with insufficient coverage for manual review.

community agreesWhy

exam-a · Q12

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

1. ASpawn the subagent with only a brief task description, relying on automatic context inheritance from the coordinator
2. BProvide the subagent with tool definitions that allow it to request outputs from other subagents via callbacks
3. CPass reference identifiers and configure the subagent with read access to a shared memory store where other subagents deposited their results
4. DInclude the complete findings from both subagents directly in the synthesis subagent’s prompt

community agreesWhy

exam-a · Q13Customer support

When the agent calls lookup_order and receives order details showing the item was purchased 45 days ago, how does the agentic loop determine whether to call process_refund or escalate_to_human next?

1. AThe orchestration layer automatically routes to the next tool based on the order’s status field.
2. BThe order details are added to the conversation and the model reasons about which action to take.
3. CThe agent executes the remaining steps in a tool sequence planned at the start of the request.
4. DThe agent follows a pre-configured decision tree mapping order attributes to specific tool calls.

nobody has checked this keyWhy

exam-a · Q14Customer support

After investigating a billing dispute over 25+ turns, you’ve identified that duplicate charges occurred due to a payment gateway timeout triggering retry logic. The required refund ($847) exceeds your $500 authorization limit You need to call escalate_to_human, and the human agent won’t have access to your conversation transcript. What context should you pass to enable effective resolution?

1. AA structured summary: customer ID, root cause, refund amount, and recommended action.
2. BYour diagnosis and the refund amount only.
3. CThe customer’s original complaint verbatim plus the tool result excerpts showing duplicate transactions.
4. DThe complete conversation transcript with all tool results.

nobody has checked this keyWhy

exam-a · Q15Customer support

Your agent is handling a billing dispute. After calling get_customer and lookup_order, it identifies 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?

1. ACompile a structured handoff with customer details, order info, and the identified issue before calling escalate_to_human.
2. BPersist the complete conversation and tool response history to a database, then call escalate_to_human with a reference ID.
3. CCall escalate_to_human passing only the customer’s original message.
4. DAttempt the refund with process_refund anyway, escalating only if the system rejects the transaction.

nobody has checked this keyWhy

exam-a · Q16Customer support

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?

1. AImplement sentiment analysis that monitors for frustration indicators (negative language, repeated questions, exclamation marks) and trigger escalation when the frustration score exceeds a configured threshold.
2. BConfigure the agent to escalate after three consecutive tool calls that fail to resolve the customer’s stated issue, ensuring a reasonable attempt before involving a human.
3. CInstruct the agent to escalate when the customer requests a human, when the issue requires policy exceptions, or when the agent cannot make meaningful progress.
4. DBuild a rules engine that maps specific issue types, customer segments, and product categories to escalation decisions, removing the need for model judgment calls.

nobody has checked this keyWhy

exam-a · Q17

Your order management system requires tools for three distinct operations: issuing refunds (requires amount and reason), canceling orders (requires reason), and requesting reshipments (requires shipping address). Each operation shares an order_id parameter but has different additional requirements. You notice during testing that with your current unified tool design, the agent frequently omits required parameters or includes irrelevant ones. What design change will most effectively improve parameter accuracy?

1. AKeep one unified tool with a nested operation_details object parameter whose internal structure varies by operation type, documented in the tool description.
2. BKeep one unified tool but add JSON Schema if-then-else conditionals to enforce that parameters like amount are required only when the operation type is “refund”.
3. CSplit into three separate tools (issue_refund, cancel_order, request_reshipment), each defining only the parameters required for that specific operation.
4. DKeep one unified tool with all parameters marked optional, but add detailed few-shot examples in the system prompt showing correct parameter combinations for each operation type.

nobody has checked this keyWhy

exam-a · Q18

Your post_content tool requires user confirmation before publishing. The current workflow displays “Ready to post to social media. Confirm?” and analytics show users approve 98% of requests within 2 seconds. Post-mortems reveal incidents where posts went to wrong accounts, were scheduled for wrong times, or contained errors – all confirmed by users without catching the mistakes. How should you redesign the confirmation workflow?

1. AAuto-approve routine posts and only require explicit confirmation for unusual patterns like posting to new accounts or large audiences
2. BRequire users to type a confirmation phrase instead of clicking a button
3. CAdd a mandatory waiting period before the confirm option becomes available
4. DInclude the complete post text, target account, scheduled time, and platform in the confirmation request

nobody has checked this keyWhy

exam-a · Q19

Your agent uses three tools: get_property_details(property_id) returns data including street address, get_price_history(property_id) returns historical pricing, and get_neighborhood_info(address) returns area statistics. You observe that get_neighborhood_info always requires get_property_details first just to extract the address, even when users specify the property by ID. This creates unnecessary latency and failure coupling – if the first call fails, the neighborhood request also fails. What tool design change best addresses this?

1. ACreate a lookup_address(property_id) helper tool for retrieving addresses.
2. BAdd retry logic and timeout handling to get_property_details.
3. CChange get_neighborhood_info to accept property_id, resolving the address internally.
4. DConsolidate into a single get_property_with_neighborhood(property_id) tool returning both datasets.

nobody has checked this keyWhy

exam-a · Q20

Your update_user_profile tool accepts a user_id (required) and an optional fields_to_update object. In testing, Claude frequently omits user_id or passes incorrectly structured data. What is most critical for helping Claude understand what parameter values to provide?

1. AStrict JSON Schema type constraints marking user_id as required and defining fields_to_update as an object type
2. BVerbose parameter names encoding format hints, such as user_id_string_uuid_format
3. CDetailed error responses explaining why invalid parameter values were rejected
4. DClear parameter descriptions explaining expected format, such as “user_id: UUID of the user to update (required)”

community agreesWhy

exam-a · Q21

Your document extraction tool uses ML models to extract invoice fields (vendor, amount, date). The models return confidence scores (0.0-1.0) for each extracted field. In production, you observe: (1) the agent proceeds with low-confidence extractions that are incorrect 23% of the time, and (2) the agent requests unnecessary human review for 31% of extractions that were actually correct. How should you restructure the tool’s output?

1. AReturn fields with their raw confidence scores and add detailed few-shot examples to your system prompt demonstrating how to interpret different confidence ranges and when to request human review.
2. BReturn fields with confidence scores, plus a request_review boolean computed using your tested confidence thresholds, along with a review_reasons array explaining which fields triggered review.
3. CCompute an aggregate extraction_quality score across all fields and return it alongside the extracted values. Include a text summary describing the overall extraction reliability.
4. DReturn fields organized into verified and needs_verification objects based on confidence thresholds.

nobody has checked this keyWhy

exam-a · Q22

Your product search tool queries an external catalog API and returns matching items. In production, you observe the agent frequently retries searches immediately after receiving zero results, treating “no matches found” as a failure requiring retry. The external API returns HTTP 200 with an empty results array – a valid response. How should you restructure the tool’s result to help the agent correctly interpret empty result sets?

1. AAdd a suggestions field containing alternative search strategies when results are empty, helping guide the agent toward more productive follow-up queries.
2. BReturn a natural language string describing the outcome, allowing the agent to interpret the result contextually based on the message content.
3. CReturn a result object with isError: true and a message explaining no products matched.
4. DReturn a structured result with a success boolean and results array, reserving isError: true for actual execution failures only.

nobody has checked this keyWhy

exam-a · Q23

Your MCP server includes archive_file(file_id) and delete_file(file_id) tools. Production logs show the agent calls delete_file when users ask to “remove old backups,” but company policy requires archiving backup files. Both tools currently have minimal descriptions: “Archives a file” and “Deletes a file.” Which change most directly improves tool selection for this scenario?

1. AExpand tool descriptions to clarify use cases, adding guidance like “Do not use for backup files” to delete_file.
2. BAdd a confirmation step that requires users to type “CONFIRM DELETE” before delete_file executes.
3. CImplement server-side validation that rejects delete_file calls for files tagged as backups, returning an error message suggesting archive_file.
4. DAdd few-shot examples to the system prompt demonstrating that requests involving “backup” or “old” should use archive_file.

community says CWhy

exam-a · Q24

Your track_shipment(tracking_id) tool queries an external logistics API that sometimes fails – the API may be temporarily unavailable, the tracking ID may be malformed, or the shipment may not exist. Currently, your tool raises a Python exception when errors occur. Users report the agent gives unhelpful responses like “I’m having trouble with that request” instead of suggesting alternatives such as verifying the tracking number format or checking by order number. How should you handle errors in tool results?

1. AReturn a generic error response (e.g., {"success": false, "error": "lookup_failed"}) for all failure cases to maintain a consistent schema and avoid exposing internal error details.
2. BReturn structured error information as normal tool output including error type, recoverability status, and actionable context for the user.
3. CCreate dedicated error-recovery tools (retry_tracking_lookup, search_by_order_number) that the model can invoke after the primary tracking tool returns a failure indicator.
4. DImplement retry logic with exponential backoff inside the tool implementation so transient errors are automatically handled and only return a result after all retry attempts are exhausted.

nobody has checked this keyWhy

exam-a · Q25

Your MCP server implements a check_availability tool that queries an external calendar API. During testing, you encounter three error conditions: (1) the tool is called with a malformed request missing the required user_email parameter, (2) the calendar API returns a 404 because the specified user doesn’t exist in the calendar system, and (3) the calendar API returns a 503 because the service is temporarily unavailable. How should each error be reported according to MCP’s error handling design?

1. AReport all three as tool results with isError: true.
2. BReport errors 1 and 2 as JSON-RPC protocol errors; report error 3 as a tool result with isError: true.
3. CReport error 1 as a JSON-RPC protocol error; report errors 2 and 3 as tool results with isError: true.
4. DReport all three as JSON-RPC protocol errors.

nobody has checked this keyWhy

exam-a · Q26

Your send_notification tool calls third-party messaging APIs. When these services time out during delivery, you cannot determine whether the message was actually sent. Currently, the tool returns is_error: true with a generic “Notification failed” message for all timeouts. Production monitoring reveals agents automatically retry these failures, frequently causing users to receive duplicate notifications. How should you modify the error response?

1. AReturn is_error: true with a structured field retry_safe: true for timeouts, distinguishing them from permanent failures that should not be retried.
2. BReturn is_error: true with a message communicating uncertainty: “Timeout – status unknown. Message may have been sent. Avoid retry.”
3. CReturn is_error: true with a message encouraging retry: “Delivery service temporarily unavailable. Please retry the notification.”
4. DReturn is_error: true with the original message content echoed back.

nobody has checked this keyWhy

exam-a · Q27

Your control_device tool manages smart home devices through external APIs. When a device doesn’t respond within the timeout period, the tool returns an error. Production logs show that the agent simply tells users “the device is not responding” without offering helpful next steps. Which error response structure would best enable the agent to provide useful follow-up?

1. ASet is_error: true with a structured technical error containing the device ID, timeout duration, and raw API response code for debugging purposes.
2. BSet is_error: true with a brief “Device offline” message and provide a separate tool the agent can call to retrieve context-specific troubleshooting suggestions.
3. CSet is_error: false with an optimistic message indicating the command was dispatched successfully but device acknowledgment is still pending.
4. DSet is_error: true with a message explaining the likely cause and suggesting troubleshooting steps the agent can offer the user.

nobody has checked this keyWhy

exam-a · Q28

Your expense reimbursement agent processes employee requests using a process_reimbursement tool. Company policy requires that reimbursements above $500 must be approved by a manager before funds are disbursed. The agent handles hundreds of requests daily, and you need the threshold enforcement to be tamper-proof regardless of how the agent is prompted. Which design ensures the $500 approval threshold cannot be bypassed?

1. AThe process_reimbursement tool accepts amount and details, and internally enforces the threshold: amounts <$500 are auto-disbursed and the tool returns a success confirmation; amounts >$500 cause the tool to create a pending approval request and return a status indicating manager review is pending.
2. BThe process_reimbursement tool accepts an approved_by_manager: boolean parameter. The system prompt instructs the agent to only set this to true after confirming that a manager has approved the request. A nightly audit script reviews all reimbursements where approved_by_manager was set to true.
3. CProvide two tools: auto_reimburse (hard-coded limit of $500) and request_manager_approval. Include detailed system prompt instructions telling the agent to check the amount and call the appropriate tool. Add a PostToolUse hook that logs which tool was called for auditing.
4. DImplement the threshold check in a PreToolUse hook that inspects the amount parameter before process_reimbursement executes. If the amount exceeds $500, the hook modifies the tool call to add a requires_approval: true flag, which the tool checks before disbursing.

nobody has checked this keyWhy

exam-a · Q29

Your content curation agent discovers articles, analyzes each for relevance, then adds selected articles to themed collections. With separate discover_articles(topic), analyze_article(id), and add_to_collection(article_id, collection_id) tools, you observe 18+ sequential tool calls per request, causing latency issues. The agent must make editorial judgments about which articles fit a collection’s theme – this requires seeing all candidates with their analysis scores simultaneously to select a cohesive set. What tool composition best addresses efficiency while preserving editorial judgment?

1. AKeep all tools separate but implement response caching for analyze_article calls.
2. BCreate a curate_collection(topic, collection_id) tool that handles discovery, analysis, and selection internally using configurable quality thresholds.
3. CCreate a discover_and_analyze(topic) composite tool that returns all candidates with their analysis scores, keeping add_to_collection separate for selective calls.
4. DAdd a preview_curation(topic, collection_id) tool that shows what would be added based on predefined rules, with an approve_curation() tool to confirm.

nobody has checked this keyWhy

exam-a · Q30Multi-agent research

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

1. AHave the coordinator pre-classify each analysis request before passing instructions to the document analysis agent
2. BKeep the single tool but add an analyze_type enum parameter requiring explicit selection between extraction, summarization, and verification modes
3. CEnhance the tool description with detailed examples showing how different instruction phrasings should map to different output formats
4. DSplit the generic tool into purpose-specific tools – extract_data_points, summarize_content, verify_claim_against_source – each with defined input/output contracts

nobody has checked this keyWhy

exam-a · Q31

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

1. AModify the refund tool to return an error with message “Amount exceeds policy limit – please escalate” when threshold is exceeded.
2. BAdd few-shot examples to the prompt showing correct escalation behavior at various refund amounts ($400, $500, $600).
3. CImplement a hook to intercept tool calls; when the refund process amount exceeds $500, block it and invoke human escalation.
4. DStrengthen the system prompt with emphatic language: “CRITICAL POLICY: Refunds over $500 MUST trigger human escalation. NEVER process these directly.”

nobody has checked this keyWhy

exam-a · Q32Customer support

Production logs reveal inconsistent error handling: when lookup_order fails, the agent sometimes retries 5+ times (wasteful when the order ID doesn’t exist), sometimes escalates immediately (premature for temporary network issues), and sometimes asks users for clarification (inappropriate when the issue is a backend permission error). Investigation shows your MCP tool returns uniform error responses: {"isError": true, "content": [{"type": "text", "text": "Operation failed"}]}. The agent cannot distinguish between error types. What’s the most effective improvement?

1. ACreate an analyze_error MCP tool the agent calls after any failure to determine the error category and recommended action.
2. BAdd few-shot examples to the system prompt demonstrating how to interpret error message patterns and select appropriate responses for each.
3. CEnhance error responses with structured metadata: include errorCategory (transient/validation/permission), isRetryable boolean, and a description of what caused the failure.
4. DImplement retry logic with exponential backoff in your MCP server for all errors, returning to the agent only after retries are exhausted.

nobody has checked this keyWhy

exam-a · Q33Customer support

When implementing your lookup_order MCP tool, the backend sometimes returns errors (e.g., “Order not found” or temporary database failures). What is the correct pattern for communicating these errors back to the agent?

1. AThrow an exception from the tool handler so the agent framework can catch and log it
2. BReturn the error message in the tool result content with the isError flag set to true
3. CLog the error server-side and return an empty result to avoid confusing the model
4. DReturn a success response with a “status” field indicating the error type

nobody has checked this keyWhy

exam-a · Q34Customer support

Your process_refund tool returns two types of errors: technical errors (“503 Service Unavailable”, “Connection timeout”) that are transient (5% of calls), and business errors (“Order exceeds 30 day return window”, “Item already refunded”) that are permanent (12% of calls). Monitoring shows the agent wastes 3-4 turns retrying business errors that can never succeed. Currently, both error types return only a plain text message to Claude. What’s the most effective way to reduce wasted retries while improving customer-facing response quality?

1. AImplement automatic retry logic at the tool level for technical errors only, passing business errors to Claude without retries.
2. BAdd few-shot examples showing how to distinguish retriable from non-retriable errors by parsing error message text.
3. CReturn structured error responses with retriable: false for business errors and a customer-friendly explanation for Claude to use.
4. DAdd a check_refund_eligibility tool that must be called before process_refund to prevent business rule violations.

nobody has checked this keyWhy

exam-a · Q35

Your get_portfolio_value tool returns the total value of a user’s investment portfolio. You’re deciding between returning a structured JSON object with explicit fields versus returning the information as a formatted text string. What is the primary advantage of using structured output with defined fields?

1. AJSON schemas automatically validate that the underlying API returned correct data before the agent processes it.
2. BStructured JSON consumes significantly fewer tokens than natural language, substantially reducing API costs.
3. CStructured JSON is processed deterministically by the model, significantly improving accuracy when extracting values.
4. DThe agent can reliably extract specific values without parsing free-form text, reducing errors in subsequent operations.

nobody has checked this keyWhy

exam-a · Q36Multi-agent research

The coordinator agent has AgentDefinitions configured for all four specialized subagents, each with appropriate descriptions, prompts, and tool restrictions. During testing, you notice the coordinator correctly reasons about when to delegate – it generates messages like “I’ll ask the web search agent to find sources on this topic” – but no subagent execution ever occurs. The coordinator then proceeds as if the delegation happened and continues with incomplete information. Logs show no errors. What is the most likely cause?

1. AThe coordinator’s max_tokens setting is too low, causing the Task tool invocation to be truncated before the subagent type parameter can be specified.
2. BThe coordinator’s allowedTools configuration doesn’t include “Task”, so while it can reason about delegation, it cannot invoke the tool required to spawn subagents.
3. CThe AgentDefinitions are configured correctly, but the coordinator’s system prompt doesn’t explicitly list the available subagent types, preventing the model from knowing they can be invoked.
4. DSubagent context isolation means task descriptions from the coordinator don’t automatically reach subagents; you need to configure explicit context forwarding in ClaudeAgentOptions.

nobody has checked this keyWhy

exam-a · Q37

Your conversational assistant frequently generates multiple clarifying questions when users make ambiguous requests. When a user asks “Can you help me with the report?”, the assistant responds: “I’d be happy to help! Could you tell me: 1) Which report? 2) What kind of help – drafting, reviewing, or formatting? 3) What’s your deadline?” User analytics show a 40% conversation abandonment rate after these multi-question responses. What’s the most effective way to reduce friction while appropriately handling ambiguity?

1. ALimit the assistant to one clarifying question per turn, using conversation history to accumulate answers over multiple exchanges rather than requesting everything upfront.
2. BAdd a preprocessing step using a smaller model to classify request ambiguity on a 1-5 scale, routing high-ambiguity requests to a clarification dialog and low-ambiguity requests directly to the assistant.
3. CModify the system prompt to instruct the assistant to make reasonable assumptions from available context, state those assumptions explicitly, and offer to adjust if the interpretation is wrong.
4. DCreate a lookup table of common request patterns with predefined default interpretations, having the assistant respond with those defaults without stating the assumptions made.

nobody has checked this keyWhy

exam-a · Q38

After 30+ turns, your conversational assistant shows noticeably slower responses and occasionally produces less coherent outputs. Investigation reveals: (1) average conversations reach 50,000 tokens by turn 35, (2) production logs show 94% of user messages only reference the previous 3- 5 exchanges, (3) the 6% of queries referencing earlier context typically ask about information the user could easily re-state. Your goal is to improve response speed and quality while maintaining good user experience. What’s the most effective approach?

1. AEnable prompt caching and continue sending the complete conversation history, using cached prefixes to reduce per-request costs while preserving all context.
2. BBuild a retrieval system that stores all conversation turns and uses semantic search to pull in relevant historical context only when the current query appears to reference past information.
3. CImplement a summarization layer that progressively compresses older conversation turns into a running summary while keeping the most recent 5-6 turns verbatim, maintaining full historical context in condensed form.
4. DImplement a sliding window keeping only the system prompt and last 8-10 turns. When users reference earlier context, acknowledge the limitation and ask them to re-state the relevant information.

community says DWhy

exam-a · Q39

Production monitoring shows that follow-up queries like “summarize what we learned about market trends” consistently take 40+ seconds. Investigation reveals the coordinator spawns the synthesis subagent for each summarization request, passing 80K+ tokens of accumulated findings. The coordinator already has these findings in its context from orchestrating the research. What’s the most effective way to improve response time for these follow-up summaries?

1. AEnable prompt caching on the synthesis subagent to reduce the overhead of repeatedly transferring the same research findings.
2. BHave the coordinator handle straightforward summarization requests directly using its existing context, reserving subagent spawning for complex analysis.
3. CPre-generate and cache summaries at multiple granularities whenever new findings accumulate.
4. DSpawn the synthesis subagent with reduced context and have it request specific findings from the coordinator on-demand.

nobody has checked this keyWhy

exam-a · Q40

A customer raises three separate issues during one session: a refund inquiry (turns 1-15), a subscription question (turns 16-30), and a payment method update (turns 31-45). At turn 48, the customer asks “What happened with my refund?” The conversation is approaching context limits. What strategy best maintains the agent’s ability to address all issues throughout the session?

1. AExtract and persist structured issue data (order IDs, amounts, statuses) into a separate context layer.
2. BSummarize earlier turns into a narrative description, preserving full message history only for the active issue.
3. CRely on MCP tools to re-fetch relevant information on demand when the customer references earlier issues.
4. DImplement sliding window context that retains the most recent 30 turns.

nobody has checked this keyWhy

exam-a · Q41Customer support

During a billing dispute resolution, your agent successfully retrieves customer info via get_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 and verify refund eligibility, but cannot actually process the refund due to the backend failure. What approach best balances first-contact resolution with appropriate error handling?

1. AExplain the billing confirm refund eligibility, acknowledge the system issue preventing immediate processing, and offer escalation or retry later
2. BConfirm the refund will be processed and close the conversation, since the system has all necessary information to complete it automatically
3. CImplement automatic retries with exponential backoff for process_refund, keeping the conversation open until the refund is successfully processed
4. DEscalate immediately to a human agent since the refund action cannot be completed

nobody has checked this keyWhy

exam-a · Q42Customer support

Your agent has called lookup_order multiple times while investigating a customer’s return requests. Each response includes 40+ fields (items, shipping details, payment info, status history). Tool outputs now represent the majority of the conversation’s context. The customer mentions two more orders they want to discuss. What’s the most effective approach before making additional lookups?

1. AMove all tool responses to a vector database with semantic indexing, retrieving relevant portions as the conversation continues
2. BProceed with additional lookups without modifying the existing tool output context
3. CHave the model generate a natural language summary of each order’s key details, replacing structured responses with prose descriptions
4. DExtract only the return-relevant fields (items, purchase date, return window, status) from each existing order response, removing verbose details

nobody has checked this keyWhy

exam-a · Q43Customer support

A customer writes: “I’ve been going back and forth on this return for days. I just want to speak to someone who can actually help me.” The agent has confirmed via lookup_order that the return is straightforward – within policy and eligible for immediate processing. What should the agent do?

1. AProcess the refund via process_refund to resolve the underlying issue, then inform them it’s complete
2. BAcknowledge frustration, inform them this is resolvable now, and offer to complete it or escalate
3. CCall escalate_to_human immediately to honor the customer’s request
4. DAsk what specifically hasn’t worked in previous attempts before deciding whether to escalate or resolve automatically

nobody has checked this keyWhy

exam-a · Q44

A customer sends: “This is frustrating. I’ve explained my issue twice and nothing is being resolved. I want to talk to a real person NOW.” The agent has not yet called any tools to investigate their account. What should the agent do?

1. AImmediately call escalate_to_human with the conversation history.
2. BBriefly explain what the agent can help with and offer to resolve the issue quickly, escalating only if the customer repeats their request.
3. CFirst call get_customer and lookup_order to gather account context, then escalate to a human agent.
4. DAcknowledge the frustration and ask one targeted question to understand the specific issue before escalating.

community says CWhy

exam-a · Q45Customer support

A customer returns 4 hours after the initial session about the same billing dispute. The previous 32-turn session contains lookup_order results showing “Status: PENDING, Expected resolution: 24-48 hours.” In testing, you observe that when resuming sessions with stale tool results, the agent often references the outdated data in responses (e.g., “I see your refund is still being processed”) even after subsequent fresh tool calls return different information. What approach most reliably handles returning customers?

1. AStart a new session, inject a structured summary of the previous interaction (issue type, actions taken, resolution status), then make fresh tool calls before engaging.
2. BResume with full history but filter out previous tool_result messages before resuming, keeping only the human/assistant turns so the agent must re-fetch needed data.
3. CResume with full history and configure the agent to automatically re-call all previously-used tools at session start to ensure data freshness.
4. DResume with full history and add a system prompt instruction telling the agent to always prefer the most recent tool results when multiple calls to the same tool exist in context.

nobody has checked this keyWhy

exam-a · Q46

The agent verifies customer identity through a multi-step process before resetting passwords. During testing, you notice that after the customer answers the third verification question, the agent asks them to provide their name again, as if the earlier exchange never happened. What’s the most likely cause of this behavior?

1. AThe verification tool is clearing the agent’s internal state after each successful validation step.
2. BClaude’s memory retention is limited to two conversational turns by default, requiring explicit configuration to extend it.
3. CThe conversation history isn’t being passed in subsequent API requests.
4. DThe prompt lacks instructions telling Claude to remember information across multiple exchanges.

nobody has checked this keyWhy

exam-a · Q47Customer support

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

1. AEnable the tool search tool with defer_loading on the six new tools, keeping the original four always loaded, so the agent dynamically discovers specialized tools only when needed.
2. BSplit the tools across two sub-agents – a “financial resolution” agent with process_refund, issue_credit,and apply_promo_code, and a “delivery operations” agent with the remaining delivery tools – with a coordinator routing between them.
3. CAdd few-shot examples to the system prompt demonstrating correct selection for each ambiguous tool pair, such as showing when issue_credit applies versus when process_refund is appropriate.
4. DConsolidate semantically overlapping tools – merge issue_credit and process_refund into a single resolve_compensation tool with an action parameter, and fold check_delivery_status into lookup_order with an optional include_tracking flag.

nobody has checked this keyWhy

exam-a · Q48Customer support

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

1. ASwitch tool_choice from “auto” to “any” to force the agent to make a tool call on every turn.
2. BUpdate the process_refund tool description to explicitly state that order_id must be obtained from a prior lookup_order call and must never be assumed or invented.
3. CPre-parse incoming customer messages to extract any order IDs mentioned, and inject them into the conversation context before passing to Claude.
4. DAdd server-side validation that checks whether the order_id exists in your database before executing the refund, returning an error to the agent if not found.

nobody has checked this keyWhy

exam-a · Q49Customer support

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

1. AImplement retry logic with exponential backoff inside each tool implementation so transient errors are resolved transparently within the tool before any failure result is surfaced to Claude in the agentic loop.
2. BAdd an error classification step in the agentic loop that intercepts tool errors before Claude sees them, tags each as “retry,” “try_alternative,” or “escalate,” and appends that recommendation to the tool result.
3. CRemove is_error: true and return the error details as normal tool content, so Claude reasons about the response as data rather than treating it as a flagged failure condition that biases retry behavior.
4. DReturn error-type-specific messages with is_error: true, e.g., “Order not found-try get_customer to search by phone” for data errors and “Database timeout (transient)-retry should succeed” for infrastructure errors.

nobody has checked this keyWhy

exam-a · Q50Customer support

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

1. AAdd system prompt instructions telling the agent to call escalate_to_human with a summary of its findings whenever it determines it cannot complete resolution within its remaining actions.
2. BSplit the workflow into two sequential agent invocations – a first agent gathers information via get_customer and lookup_order, then a second agent receives that data and handles process_refund or escalate_to_human, each with separate turn budgets.
3. CAdd orchestration-layer code that checks the agent’s outcome after each loop termination – if the loop ended without a completed resolution or escalation, programmatically call escalate_to_human with the accumulated conversation context and tool results.
4. DImplement a pre-tool-use hook that counts tool invocations and terminates the loop with an automatic escalation once the agent reaches 80% of its max_turns limit.

nobody has checked this keyWhy

exam-a · Q51Customer support

A customer contacts the agent about a warranty claim on a power drill. Resolving this requires multiple sequential tool calls: get_customer to look up their account, lookup_order to find the purchase details, and then either process_refund or escalate_to_human depending on warranty eligibility. You’re implementing the agentic loop that orchestrates these steps using the Claude API. What is the primary mechanism your application uses to determine whether to continue the loop or stop?

1. AYou manually set the tool_choice parameter to “none” after the final expected tool call to force Claude to stop requesting tools.
2. BYou check whether Claude's response contains a text content block – if text is present, the agent has produced its final answer and the loop should exit.
3. CYou track the number of tool calls made and exit the loop once a preconfigured maximum is reached.
4. DYou check the stop_reason field in each API response – the loop continues while it equals “tool_use” and exits when it changes to “end_turn” or another terminal value.

nobody has checked this keyWhy

exam-a · Q52Claude Code workflow

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

1. AConfigure a PostToolUse hook with an Edit|Write matcher that automatically runs Prettier on each file Claude modifies.
2. BSplit the formatting rules into path-scoped.claude/rules/files that load when Claude works on matching file types.
3. CExtract the formatting rules into a dedicated skill that Claude loads automatically when generating code, with more detailed examples of correct formatting.
4. DAdd a Stop hook with a prompt-based check that evaluates whether generated code follows formatting standards and prompts Claude to fix violations.

nobody has checked this keyWhy

exam-a · Q53Claude Code workflow

This requires adding a conditional statement to one existing function in a single file. What is the most appropriate approach?

1. AEnter plan mode first to create a detailed implementation strategy before making the change.
2. BEnter plan mode to analyze how the validation might impact other parts of the reservation flow.
3. CUse direct execution to make the change.
4. DStart with extended thinking mode enabled to ensure thorough reasoning about the validation logic.

nobody has checked this keyWhy

exam-a · Q54Claude Code workflow

Your infrastructure-as-code repository includes Terraform modules (/terraform/), Kubernetes manifests (/kubernetes/), and CI/CD pipeline scripts (/pipelines/). Each requires different conventions, but your single root CLAUDE.md has grown to 500+ lines. When developers work on Kubernetes files, Terraform-specific rules load into context unnecessarily, consuming tokens. What is the best approach to reorganize so only relevant guidance loads when editing specific file types?

1. ASplit content into subdirectory CLAUDE.md files (/terraform/CLAUDE.md, /kubernetes/CLAUDE.md), so Claude loads directory-specific guidance.
2. BKeep the root CLAUDE.md and use @path/to/import syntax to modularly include tool-specific guidance files from separate documents.
3. CRestructure the root CLAUDE.md into clearly labeled sections with headers (e.g, “## Terraform Conventions”), improving organization and readability.
4. DCreate files in.claude/rules/ with YAML frontmatter path-scoping (e.g., paths: [“terraform/**/*”]), loading rules only when editing matching files.

nobody has checked this keyWhy

exam-a · Q55Claude Code workflow

You’re implementing a complex graph traversal algorithm with specific performance requirements and edge cases to handle (disconnected nodes, cycles, weighted edges). You want to structure your workflow for efficient iterative refinement with Claude. What approach will most effectively enable progressive improvement across multiple iterations?

1. AHave Claude extensively research the algorithm and create a detailed implementation plan using extended thinking, then implement the complete solution based on that plan.
2. BProvide Claude with a reference implementation from documentation, then ask it to rewrite the code to match your codebase style and add the required edge case handling, comparing outputs against the reference.
3. CProvide Claude with a detailed natural language specification of the algorithm, including all requirements and edge cases. Review each output manually and provide descriptive feedback on what behavior needs to change.
4. DWrite a test suite covering expected behavior, edge cases, and performance requirements before implementation. Ask Claude to write code that passes the tests, then iterate by sharing test failures with each refinement request.

nobody has checked this keyWhy

exam-a · Q56Claude Code workflow

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

1. AAdd a more detailed code examples to your CLAUDE.md showing the exact ApiError usage pattern for different endpoint types.
2. BRun /memory to check which memory files are loaded and verify your CLAUDE.md is included.
3. CSearch for conflicting instructions in ~/.claude/CLauDe.md or ~/.claude/rules/ that might override your project conventions.
4. DCreate path-specific rules in.claude/rules/handlers.md with YAML frontmatter scoping the error handling instructions to your API handler files.

nobody has checked this keyWhy

exam-a · Q57Claude Code workflow

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

1. AThey are surfaced as @ -mentionable resources alongside files, fetched and attached to your message when referenced.
2. BThey are automatically prepended to every conversation as additional system-level context, influencing Claude’s behavior throughout the session.
3. CThey are added to Claude Code’s tool registry alongside the server’s tools, invoked automatically by the model when relevant to the task.
4. DThey appear as slash commands (e.g., mcp_servername_deploy_checklist) that you can invoke, with arguments passed after the command name.

nobody has checked this keyWhy

exam-a · Q58Claude Code workflow

You’re implementing a new payment processing module that must follow your project’s established patterns for database transactions, error handling, and audit logging. You’ve identified three existing modules that exemplify these patterns: db_utils.py, error_handlers.py, and audit_logger.py. This is a one-off integration task – these patterns are well-documented in your team wiki and don’t need additional project-level documentation. What’s the most effective approach?

1. AAdd documentation of each pattern to your CLAUDE.md file, establishing them as project conventions that Claude will apply automatically.
2. BDescribe the patterns from the three modules in natural language in your prompt, explaining the transaction handling approach, error format, and logging conventions Claude should follow.
3. CAsk Claude to explore your codebase to find and understand the transaction, error handling, and logging patterns before generating the new module.
4. DUse @ references to include the three modules directly in your prompt, giving Claude concrete code examples of the patterns to follow.

nobody has checked this keyWhy

exam-a · Q59Claude Code workflow

Your team is configuring MCP servers in Claude Code. You want to add a shared venue lookup server that all team members should have access to, and you personally want to add an experimental music playlist server that only you are testing. Which configuration approach correctly applies MCP server scopes?

1. AAdd both servers to your local ~/.claude.json
2. BAdd venue server to ~/.claude.json and playlist server to.mcp.json
3. CAdd venue server to.mcp.json and playlist server to ~/.claude.json.
4. DAdd both servers to the project-level.mcp.json file

nobody has checked this keyWhy

exam-a · Q60Claude Code workflow

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

1. ACreate.claude/rules/ files for each standard with YAML frontmatter paths listing every package directory where that standard should apply.
2. BPut all standards in the root CLAUDE.md with override instructions like “ignore security-rules.md when working in packages that don’t handle user data.”
3. CCreate a shared-stendards.md that uses @imports to combine all three standards, then have each package’s CLAUDE.md import that combined file.
4. DUse @imports in each package’s CLAUDE.md to reference only the specific standard files relevant to that package, based on the maintainer’s domain knowledge.

nobody has checked this keyWhy

exam-a · Q61Claude Code workflow

Your team has three requirements for Claude Code’s behavior in your project 1. Claude must never modify files in the db/migrations/ directory 2. Claude should prefer your custom logging module over console.log 3. All TypeScript files must be auto-formatted with Prettier after every edit All three are currently written as instructions in your project’s CLAUDE.md. During a complex refactoring session, a developer discovers that Claude edited a migration file, violating requirement #1. How should you restructure these requirements across Claude Code's configuration mechanisms?

1. AAdd Edit(./db/migrations/**) to permissions.deny in the project settings, keep the logging preference in CLAUDE.md, and add a PostToolUse hook on the Edit tool that runs Prettier on changed TypeScript files.
2. BMove all three requirements into.claude/rules/ as path-scoped rules: one targeting db/migrations/** that forbids editing those files, and others targeting **/*.ts for the logging convention and formatting instruction.
3. CRewrite all three requirements in CLAUDE.md using stronger directive language and add few-shot examples that demonstrate Claude refusing to edit migration files and running Prettier after edits.
4. DConfigure hooks for all three: a PreToolUse hook script that blocks Edit calls targeting db/migrations/,a PreToolUse hook script that adds logging convention context before edits, and a PostToolUse hook that runs Prettier after TypeScript edits.

nobody has checked this keyWhy

exam-a · Q62Claude Code workflow

Your team frequently migrates React components to Vue. You’ve written a step-by-step workflow for Claude Code to follow during each migration, and you want every developer on the team to invoke it by typing /migrate-component. The workflow should stay in sync as the team iterates on it. Where should you place the skill file?

1. AIn ~/.claude/skills/migrate-component/SKILL.md on each developer’s machine
2. BIn.claude/skills/migrate-component/SKILL.md at the project root, committed to version control
3. CIn the project’s.claude/settings.json using a skillOverrides entry to register and define the workflow
4. DAs a detailed instruction block in the project’s root CLAUDE.md file

nobody has checked this keyWhy

exam-a · Q63Claude Code workflow

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

1. AManually edit the generated code to fix the null handling, then continue working with Claude on other parts.
2. BAdd “think harder about edge cases” to your prompt and request a complete rewrite of the migration logic.
3. CDescribe the null value problem in detail and ask Claude to regenerate the entire script with improved edge case handling.
4. DProvide a test case with example input containing null values and the expected output, then ask Claude to fix it.

nobody has checked this keyWhy

exam-a · Q64Claude Code workflow

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

1. AStart with a minimal request: “Add Redis caching to /products with 5-minute TTL.” Add features and fix issues through follow-up prompts as problems surface during testing.
2. BWrite a specification with your known requirements and “TBD” markers for uncertain areas, having Claude propose solutions for each TBD as it implements.
3. CAsk Claude to interview you about the caching requirements before implementing, surfacing considerations like invalidation strategies, cache layers, consistency guarantees, and failure modes.
4. DUse plan mode to analyze the current/products endpoint implementation, then provide your caching requirements once Claude explains how the existing code is structured.

nobody has checked this keyWhy

exam-a · Q65Claude Code workflow

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

1. ACreate a /review slash command containing the checklist, invoked when starting reviews.
2. BCreate a dedicated review subagent with the checklist embedded in its configuration.
3. CConfigure plan mode as the default for code review sessions.
4. DAdd the checklist to the project’s CLAUDE.md file under a “Code Review” section.

nobody has checked this keyWhy

exam-a · Q66Claude Code workflow

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

1. AStart with direct execution to gather initial information, then switch to plan mode to design a comprehensive solution before implementing any changes.
2. BEnter plan mode to explore the module’s architecture and dependencies before attempting any fixes.
3. CUse plan mode to analyze the error in context of the module’s design, enumerate potential root causes, and prioritize fixes systematically.
4. DUse direct execution to examine the stack trace, read the relevant code, and implement a fix once you identify the root cause.

community says DWhy

exam-a · Q67Developer tooling

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

1. AStart two fresh sessions, having each re-read the relevant source files before beginning.
2. BResume the analysis session with fork_session enabled, creating a separate branch for each testing strategy.
3. CExport the analysis session's key findings to a file, then create two new sessions that reference this file.
4. DContinue in the original session, developing end-to-end tests first, then snapshot tests sequentially.

nobody has checked this keyWhy

exam-a · Q68Developer tooling

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

1. AUse the Read tool to sequentially load all 15 files, building complete understanding across the full caching implementation.
2. BUse Glob to find files matching common caching patterns (cache.py, caching/), prioritize the largest files by reading them first, then check smaller files for gaps.
3. CAnalyze imports and class hierarchies to identify the base cache class, Read that file to understand the interface, then trace specific invalidation implementations.
4. DUse Grep to search for “invalidate” and “expire” patterns across all files, then Read only those specific line ranges with minimal surrounding context.

nobody has checked this keyWhy

exam-a · Q69Developer tooling

An engineer sees an unfamiliar error message “SYNC_CONFLICT: entity version mismatch detected” in production logs but doesn’t know which of the 12 services in the codebase generates it. They ask the agent to help locate the source code. What exploration approach will most efficiently find the responsible code?

1. AUse Glob to find files in directories commonly associated with error handling (such as errors/, exceptions/,or handlers/) across all services, then Read each matching file.
2. BRead the project’s README and service configuration files to understand the architecture, then systematically Read source files in each service directory.
3. CUse Grep to search for distinctive text from the error message (like “SYNC_CONFLICT” or “entity version mismatch”), then Read the matching files to understand context.
4. DUse Grep to find all files that import the project’s error handling module, then Read those files to locate custom error definitions.

nobody has checked this keyWhy

exam-a · Q70Developer tooling

After integrating a local MCP server providing code analysis tools (analyze_dependencies, find_dead_code, calculate _complexity), you verify the server is healthy and tools appear in the tools/list response. However, you observe that the agent consistently uses Grep to search for import statements instead of calling analyze_dependencies –even when users explicitly ask about “code dependencies.” Examining tool definitions reveals: • MCP: analyze_ dependencies – “Analyzes dependency graph” • Built-in: Grep – “Search file contents for a pattern using regular expressions. Returns matching lines with line numbers and surrounding context.” What's the most effective approach to improve the agent's selection of MCP tools?

1. AAdd routing instructions to the system prompt specifying that dependency-related questions should use MCP tools rather than Grep.
2. BRemove Grep from available tools when the MCP server is connected to eliminate functional overlap.
3. CSplit analyze_dependencies into granular tools (list_imports, resolve_transitive_deps, detect_circular_deps) so each has a focused purpose less likely to overlap with Grep.
4. DExpand MCP tool descriptions to detail capabilities and outputs – e.g., “Builds dependency graph showing direct imports, transitive dependencies, and cycles.”

nobody has checked this keyWhy

exam-a · Q71Developer tooling

Your agent has spent 25 minutes exploring a game engine's rendering subsystem –reading shader code, buffer management, and frame synchronization logic. An engineer now asks it to understand how the physics engine integrates with rendering for collision debug overlays. You notice recent responses reference “typical rendering patterns” rather than the specific VulkanPipeline and FrameGraph classes it discovered earlier. What’s the most effective approach?

1. AContinue in the current context with more targeted prompts referencing the specific classes by name.
2. BSummarize key rendering findings, then spawn a sub-agent for physics exploration with that summary in its initial context.
3. CSpawn a sub-agent to explore physics independently, then manually synthesize its findings with the rendering knowledge accumulated in the main conversation.
4. DUse /clear to reset context completely, then start fresh with physics exploration using file paths from the project's CLAUDE.md.

nobody has checked this keyWhy

exam-a · Q72Developer tooling

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

1. AStart fresh session to ensure the agent works with current codebase state without stale assumptions
2. BResume the session and inform the agent which specific files changed for targeted re-analysis
3. CResume the session and immediately have the agent re-read all 12 previously analyzed files
4. DResume the session without informing the agent about the changed files

nobody has checked this keyWhy

exam-a · Q73Developer tooling

Your code review assistant needs to analyze pull requests and provide feedback on three aspects: code style compliance, potential security issues, and documentation completeness. Each aspect requires reading files, running analysis tools, and generating a report section. The review process follows the same three-step workflow for every PR. Which task decomposition pattern is most appropriate for this workflow?

1. ARouting – classify each PR by type (feature, bugfix, refactor) first, then route to different review prompts optimized for that category.
2. BPrompt chaining – break the review into sequential steps where each aspect (style, security, documentation) is analyzed separately, with outputs combined in a final synthesis step.
3. CSingle comprehensive prompt – include all instructions in one prompt and let the model handle all three aspects simultaneously.
4. DOrchestrator-workers – have a central LLM analyze each PR to dynamically determine which checks are needed, then delegate to specialized worker LLMs for each identified subtask.

nobody has checked this keyWhy

exam-a · Q74Developer tooling

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

1. AImplement a request classifier that detects refactoring intent and automatically routes those requests to the MCP server before the agent processes them.
2. BRemove the Write tool from the agent’s configuration for refactoring sessions so it must use the MCP tools for code modifications.
3. CAccept this as expected behavior since simpler tools like sed are more predictable than specialized refactoring tools.
4. DEnhance the MCP tool descriptions to explain when each tool is preferable to text manipulation and clarify expected inputs and outputs.

nobody has checked this keyWhy

exam-a · Q75Developer tooling

A developer asks the agent to investigate why a specific API endpoint intermittently returns 500 errors. The codebase has 200+ files and the developer doesn't know which components are involved. The agent must trace the error through routing, middleware, business logic, and database layers. What task decomposition approach would be most effective?

1. AHave the agent dynamically generate investigation subtasks based on what it discovers at each step, adapting its exploration plan as new information about the error path emerges.
2. BHave the agent first create a comprehensive plan mapping all code paths through the endpoint before beginning any file exploration or code reading.
3. CRun parallel worker agents that simultaneously investigate all four layers, then synthesize their findings to identify where the error originates.
4. DDefine a fixed sequence of investigation steps upfront – grep for error patterns, then read error handlers, then check database queries, then examine middleware – executing each step regardless of intermediate findings.

nobody has checked this keyWhy

exam-a · Q76Developer tooling

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

1. AUse Edit with an extremely long old_string capturing 30+ lines of context to guarantee uniqueness
2. BUse Bash to append the function definition to the end of the file using heredoc syntax
3. CUse Edit’s replace_all parameter to target a common pattern and embed the new function in the replacement text
4. DUse Read to load the file, add the function at the appropriate location, then Write the updated file

nobody has checked this keyWhy

exam-a · Q77Developer tooling

An engineer used the agent yesterday to analyze a legacy authentication module, identifying two distinct refactoring approaches: extracting a microservice versus refactoring in-place. Today, they want to explore both approaches in depth – having the agent propose specific code changes for each – before deciding which to implement. What’s the most effective way to structure this exploration?

1. AStart two fresh sessions, manually providing a summary of yesterday’s analysis findings to establish context.
2. BResume yesterday’s session and explore both approaches sequentially within the same conversation thread.
3. CResume yesterday’s session to explore the first approach, then start a new session for the second, manually recreating the original context.
4. DUse fork_session to create two branches from yesterday’s analysis, exploring one approach in each fork.

nobody has checked this keyWhy

exam-a · Q78Developer tooling

An engineer asks your agent to identify untested code paths in a legacy payment processing module spanning 45 files. After reading the first 8 source files, the agent's responses are becoming noticeably less accurate – it's forgetting previously discussed code patterns and hasn't yet located all test files or traced critical payment flows. What’s the most effective approach to complete this investigation?

1. ASwitch to using Grep to search for specific function names instead of reading full files, reducing the content loaded into context for remaining exploration.
2. BSpawn subagents to investigate specific questions (e.g., “find all test files for payment processing,” “trace refund flow dependencies”) while the main agent coordinates findings and preserves high-level understanding.
3. CDocument all current findings in a summary report, clear context completely, then use that report as the sole reference for continuing the investigation.
4. DClear context with /clear, then selectively re-read only the most critical files discovered so far, writing key findings to a scratchpad file that persists between context resets.

nobody has checked this keyWhy

exam-a · Q79Developer tooling

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

1. AImplement automatic context clearing every 15 minutes to ensure the agent starts with fresh, uncontaminated context.
2. BSwitch to a higher-capacity model tier to provide more context window space for accumulated exploration data.
3. CCreate summaries of all source files before exploration begins, loading only these compressed representations into context.
4. DHave the agent maintain a scratchpad file that records key findings, referencing it for subsequent questions.

nobody has checked this keyWhy

exam-a · Q80Developer tooling

An engineer submits two requests: • Request A: “Rename the getUserData function to fetchUserProfile everywhere it’s used.” • Request B: “Improve error handling throughout the data processing module – add try/catch blocks, meaningful error messages, and ensure failures don’t silently corrupt data.” For which request does specifying an explicit multi-phase workflow (such as analyze –> propose –> implement with review) most improve outcome quality?

1. ANeither request benefits significantly
2. BRequest A, the function rename task
3. CBoth requests benefit equally
4. DRequest B, the error handling task

nobody has checked this keyWhy

exam-a · Q81Developer tooling

An engineer asks the agent to find all files in the monorepo that import the @company/auth package to understand how authentication is used across services. Which built-in tool is most appropriate for this task?

1. ARead, starting with package.json files to trace dependency declarations
2. BGlob, to find files with “auth” in their filename or path
3. CGrep, to search for the import statement pattern across file contents
4. DBash, to execute find. –type d –name “*auth*” and explore matching directories

nobody has checked this keyWhy

exam-a · Q82Multi-agent research

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

1. AInstruct the synthesis agent to always treat the most recent data as authoritative and place older findings in a separate historical appendix.
2. BAdd a conflict resolution agent that automatically discards older data when newer data exists for the same metric.
3. CRequire subagents to include publication or data collection dates in their structured outputs.
4. DConfigure the web search agent to only return results from the past 6 months.

nobody has checked this keyWhy

exam-a · Q83Multi-agent research

In production, you observe that simple fact-checking queries (e.g., “What year was the Paris Climate Agreement signed?”) traverse all four subagents sequentially, consuming 40+ seconds and significant tokens per query. Complex comparative research benefits from the full pipeline. Your query distribution is diverse and evolving as users discover new applications. What’s the most effective approach to optimize for varying query complexity?

1. ACreate a fast-path for factual questions that bypasses subagents entirely, routing all other queries through the complete pipeline to ensure research thoroughness.
2. BImplement pattern-based routing that categorizes queries by structure (single-fact vs. comparative vs. analytical) and maps each category to a predefined subagent combination.
3. CTrain a query complexity classifier on labeled historical data to predict optimal subagent combinations, retraining periodically as query patterns evolve.
4. DHave the coordinator analyze each query and dynamically decide which subagents to invoke based on its assessment of query requirements.

nobody has checked this keyWhy

exam-a · Q84Multi-agent research

When analyzing complex legal cases that cite multiple precedents, the document analysis subagent processes each sequentially. A landmark case citing 12 precedents takes over 3 minutes to analyze completely. What’s the most effective way to reduce this latency while preserving the coordinator’s ability to monitor and debug the system?

1. ACreate a recursive agent hierarchy where analysis agents subdivide work among child agents until reaching single-precedent granularity
2. BHave the coordinator spawn parallel document analysis subagents, each handling a subset of precedents, then aggregate results before synthesis
3. CEnable the document analysis subagent to spawn its own specialized subagents dynamically when it encounters cases with many citations
4. DImplement a message queue where precedent analysis tasks are processed asynchronously by a pool of worker agents

nobody has checked this keyWhy

exam-a · Q85Multi-agent research

A user is expanding the research system beyond its single web search agent by adding specialized data sources. They add a financial API agent that returns structured JSON with revenue, margins, and growth rates; a news monitoring agent that returns prose summaries of recent developments; and a patent analysis agent that returns structured lists of technology areas. The synthesis agent combines these into executive briefings. Currently, it converts everything to bullet points, causing financial comparisons to lose tabular clarity and news summaries to lose narrative flow. What change would most improve briefing quality?

1. AUpdate the synthesis agent to render each content type appropriately – financial data as tables, news as prose
2. BStandardize all subagent outputs to prose summaries with inline citations
3. CStandardize all subagent outputs to JSON with fields for claim, evidence, source, and confidence
4. DAdd a format conversion layer between subagents and synthesis that transforms all outputs to a common intermediate representation

nobody has checked this keyWhy