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