📘 Free CCDV-F Sample Questions
Scenario: Developer Productivity with Claude You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate repetitive tasks. It uses built-in tools (Read, Write, Bash, Grep, Glob) and integrates with MCP servers. During a legacy payment module analysis, the coordinator first assigns one subagent to map database tables and another to trace API callers. Both return useful findings. The coordinator then invokes a planning subagent to propose a migration strategy, but the plan ignores the database constraints and caller list already discovered, recommending changes that would break known integrations.
What should you change to make this orchestration more reliable?
A
Replace the specialized subagents with one long-running generalist subagent that performs discovery and planning together.
B
Instruct the planning subagent to infer missing dependencies from file names when prior findings are unavailable.
C
Allow subagents to message each other directly so the planning subagent can request missing analysis details.
D
Have the coordinator maintain shared investigation state and include relevant prior findings in each subsequent subagent prompt.
Correct Answer:
D. Have the coordinator maintain shared investigation state and include relevant prior findings in each subsequent subagent prompt.
Explanation:
Coordinator-owned state is central to reliable multi-agent orchestration. In a coordinator-subagent pattern, the coordinator decomposes work, collects results, and decides which findings must be supplied to later subagents so they can produce grounded outputs.
The underlying principle is that subagents operate in isolated task contexts. They should not be designed as if they can automatically see prior coordinator conversations or other subagents' outputs. The coordinator should maintain a structured investigation state, such as discovered tables, caller lists, constraints, open questions, and confidence notes, then include the relevant subset in each downstream prompt.
Letting subagents communicate directly weakens the hub-and-spoke architecture by hiding information flow from the coordinator. Replacing specialists with one generalist can create context bloat and reduce the value of parallel specialized analysis. Asking a planning subagent to infer missing dependencies from file names is especially risky because it substitutes guesses for evidence.
For more on agent orchestration and subagent patterns, see the Agent SDK documentation and the Claude Code Sub-agents documentation.
Scenario: Structured Data Extraction You are building a structured data extraction system using Claude. The system extracts information from unstructured documents, validates output using JSON schemas, and maintains high accuracy. It must handle edge cases gracefully and integrate with downstream systems. Your extraction QA pass reviews Claude's JSON outputs before downstream ingestion. Reviewers dismiss many findings because the QA prompt flags harmless differences: inferred date formats, optional fields absent from the source, and wording variations that do not change extracted values. The current prompt says, "Check the extraction for accuracy and report any problems.".
What change would most effectively improve precision?
A
Increase the validation sample size and ask reviewers to manually ignore findings that are not actionable.
B
Add instructions that Claude should be conservative and report only findings where it feels highly confident.
C
Rewrite the QA prompt to define reportable errors, acceptable variations, and skip conditions with concrete examples for each category.
D
Require the QA pass to flag every schema field that is null, even when the source document omits it.
Correct Answer:
C. Rewrite the QA prompt to define reportable errors, acceptable variations, and skip conditions with concrete examples for each category.
Explanation:
Explicit criteria are the most effective way to improve precision when a prompt produces false positives. A prompt like "check for accuracy" leaves Claude to infer what counts as an issue, so it may flag harmless formatting differences, valid nulls, or stylistic variations as problems.
The stronger approach is to define reportable categories, acceptable variations, and skip conditions. For example, report a value that contradicts the source or a source-present required field that was omitted, but skip optional fields absent from the document and normalized formats that preserve meaning.
Instructions such as "be conservative" or "only report high-confidence findings" are weak substitutes because they do not create operational decision boundaries. Flagging all null fields is also counterproductive in extraction systems, since nullable fields are often necessary to avoid fabrication when source data is absent.
The underlying principle is that precision improves when the model receives concrete decision rules and examples rather than broad quality goals. Learn more about prompt specificity and examples in Prompt Engineering.
Scenario: Structured Data Extraction You are building a structured data extraction system using Claude. The system extracts information from unstructured documents, validates output using JSON schemas, and maintains high accuracy. It must handle edge cases gracefully and integrate with downstream systems. Your invoice extractor currently asks Claude to "return valid JSON" with fields for vendor, invoice_date, line_items, and total_amount. In production, a small but persistent share of responses include markdown fences, explanatory text, or malformed commas, causing downstream parsers to reject otherwise correct extractions.
What change would most effectively improve structured output reliability?
A
Keep requesting JSON only, then strip markdown fences and trailing prose with regular expressions before parsing.
B
Add stronger prompt wording that forbids explanations, examples, markdown, comments, and any non-JSON characters in every response.
C
Define an extraction tool with a JSON schema for target fields, then consume the structured tool_use input directly.
D
Use assistant prefill with an opening brace and stop sequences, then parse the generated text as JSON.
Correct Answer:
C. Define an extraction tool with a JSON schema for target fields, then consume the structured tool_use input directly.
Explanation:
Structured output reliability is highest when the application uses Claude's tool use mechanism with a JSON schema representing the desired extraction fields. The model emits a tool_use block whose input conforms to the declared schema, so the application consumes structured arguments rather than scraping JSON from natural language text.
The underlying principle is to avoid treating machine-readable output as ordinary prose. Prompt-only instructions, assistant prefill, and stop sequences can improve formatting, but they still rely on text generation and parsing. For production extraction pipelines, tool use with schemas directly addresses JSON syntax failures such as markdown fences, extra commentary, and malformed delimiters.
Regex cleanup is especially brittle because it creates an ad hoc repair layer that can silently corrupt data or fail on new formatting variants. Stronger wording is also insufficient when downstream systems require consistent parseability rather than best-effort compliance. Learn more in the Tool
Use documentation and the Claude API & SDK documentation.
Scenario: Multi-Agent Research System You are building a multi-agent research system using the Claude Agent SDK. A coordinator agent delegates to specialized subagents: one searches the web, one analyzes documents, one synthesizes findings, and one generates reports. The system researches topics and produces comprehensive, cited reports. A user requests a report comparing how proposed AI copyright rules affect music licensing, model training data, and independent film production across the same jurisdictions and dates. Logs show the coordinator routes the entire request to one document analysis pass, then asks the report agent to write separate sections. The final report deeply covers licensing, barely addresses training data, and gives recommendations that conflict across sectors. What workflow change would most effectively improve the result?
A
Split the request into distinct concern threads, investigate them in parallel with shared constraints, then synthesize one unified cross-sector report.
B
Process the concerns sequentially from highest commercial value to lowest, finalizing each report section before starting the next concern.
C
Add an instruction that the report agent should mention every requested sector at least once before delivering the final answer.
D
Ask every subagent to independently analyze the full user request, then concatenate their outputs into the final report document.
Correct Answer:
A. Split the request into distinct concern threads, investigate them in parallel with shared constraints, then synthesize one unified cross-sector report.
Explanation:
Correct workflow pattern: Compound requests should be decomposed into distinct concerns that can be investigated with focused attention, while shared constraints such as jurisdictions, dates, source requirements, and definitions are passed into each investigation. The coordinator can then synthesize the findings into a single report that reconciles interactions, conflicts, and dependencies across the concerns.
The underlying architectural principle is to separate focused parallel investigation from unified synthesis. A single broad pass risks attention dilution, while independent full-scope analyses create duplication and inconsistent assumptions. Sequentially finalizing sections can also produce incompatible conclusions because cross-concern relationships are not evaluated until too late.
The reporting-stage instruction is a common anti-pattern: it asks the final writer to cosmetically cover every topic without ensuring that the research workflow gathered enough evidence for each topic.
Reliable multi-step workflows assign distinct items, preserve shared context, and require synthesis before final reporting.
Learn more about agent orchestration and tool-based workflows in the Agent SDK documentation and the Tool Use guide.
Scenario: Customer Support Resolution Agent You are building a customer support resolution agent using the Claude Agent SDK. The agent handles high-ambiguity requests like returns, billing disputes, and account issues. It has access to backend systems through MCP tools (get_customer, lookup_order, process_refund, escalate_to_human). Your target is 80%+ first-contact resolution while knowing when to escalate. Production logs show that lookup_order and process_refund both return the same failure text, "Operation failed." The agent retries declined refunds, tells customers to try again later when they provided invalid order IDs, and escalates temporary timeout cases that would likely succeed on retry. What change would best improve the agent's recovery decisions?
A
Route all refund and order lookup failures to escalate_to_human, avoiding autonomous recovery entirely after backend errors.
B
Return MCP tool errors with isError plus category, retryability, and safe messages distinguishing transient, validation, business, and permission failures.
C
Standardize every tool failure as a generic message, then ask Claude to infer recovery steps from conversation context.
D
Retry every failed backend tool call three times, then escalate unresolved cases without exposing error details to Claude.
Correct Answer:
B. Return MCP tool errors with isError plus category, retryability, and safe messages distinguishing transient, validation, business, and permission failures.
Explanation:
Structured error responses let an agent make different decisions for different failure modes instead of treating every backend problem as the same event. In practice, an MCP tool should use an error signal such as isError and include metadata like errorCategory, isRetryable, and a human-readable explanation that is safe to show or summarize to the customer.
The underlying principle is that recovery logic depends on the nature of the failure: transient errors may be retried, validation errors usually require corrected input, business errors such as policy declines should be explained without retrying, and permission errors may require escalation or access handling. Generic failure text prevents Claude from selecting the right path and often causes wasted retries, premature escalation, or misleading customer responses.
Fixed retry counts are an anti-pattern when used as the primary response to all failures, because they ignore whether the error is actually retryable. Escalating every tool failure is also too conservative for an 80%+ first-contact resolution target, since many cases can be recovered locally with the right error details.
Learn more about MCP tool behavior in MCP Tools and Claude tool orchestration in Tool Use.
Scenario: Developer Productivity with Claude You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate repetitive tasks. It uses built-in tools (Read, Write, Bash, Grep, Glob) and integrates with MCP servers. An engineer asks the agent to explain how the "user export" capability works in a legacy repository. The final answer confidently covers REST controllers and serializers, but misses scheduled exports, admin-triggered jobs, and CLI invocations. Logs show every subagent completed successfully; their prompts were "inspect export controller," "trace export API request," and "summarize export endpoint tests.".
What should you change first to improve coverage on similar broad codebase questions?
A
Require each subagent to read every file matching export-related terms before returning any findings to the coordinator.
B
Run a fixed pipeline that always invokes controller, database, CLI, worker, and test subagents for every codebase query.
C
Strengthen the synthesis subagent prompt to infer missing workflows from naming conventions and common framework patterns.
D
Revise coordinator planning to identify plausible entry points, then delegate distinct code areas to subagents before synthesis.
Correct Answer:
D. Revise coordinator planning to identify plausible entry points, then delegate distinct code areas to subagents before synthesis.
Explanation:
The root issue is the coordinator's task decomposition, not subagent execution. The subagents completed successfully, but all assigned prompts focused on the REST API path, so the final answer missed other relevant workflows such as scheduled jobs, admin actions, and CLI commands.
For broad codebase exploration, the coordinator should first reason about the possible surfaces where a capability may appear, such as controllers, jobs, commands, tests, database models, and integrations. It can then delegate distinct areas to specialized subagents and aggregate their findings into a complete explanation.
Asking synthesis to infer missing workflows is an anti-pattern because it encourages unsupported guesses. Having every subagent read every matching file creates context bloat and attention dilution, while a fixed pipeline wastes work and ignores the need for dynamic routing based on query complexity. The underlying principle is that a coordinator-subagent architecture depends on the coordinator to preserve coverage and routing discipline. Learn more about agent orchestration patterns in the Agent SDK documentation.
Scenario: Multi-Agent Research System You are building a multi-agent research system using the Claude Agent SDK. A coordinator agent delegates to specialized subagents: one searches the web, one analyzes documents, one synthesizes findings, and one generates reports. The system researches topics and produces comprehensive, cited reports. Your document-analysis subagent receives 45 reports and policy papers in a single pass before synthesis. The final outputs cite many sources but miss source-specific caveats, merge incompatible methodologies, and sometimes contradict earlier extracted facts.
What workflow change would most effectively improve reliability?
A
Analyze each source in a focused pass with structured findings, then run a separate cross-source integration pass before reporting.
B
Partition sources randomly across parallel subagents, concatenate their summaries, and have the report agent polish the combined narrative.
C
Set a maximum number of synthesis iterations and stop once the report includes citations from every source category.
D
Send all sources to the synthesis agent together and instruct it to be more careful with citations and contradictions.
Correct Answer:
A. Analyze each source in a focused pass with structured findings, then run a separate cross-source integration pass before reporting.
Explanation:
Prompt chaining is appropriate when a workflow has predictable stages that benefit from focused attention. In this case, the reliable structure is to analyze each source or small source group first, producing structured findings with caveats and provenance, then run a separate cross-source integration pass before report generation.
The architectural principle is to avoid forcing one model call to juggle too many competing responsibilities at once. A focused local pass improves extraction quality, while the integration pass explicitly compares evidence, identifies contradictions, and prepares a coherent synthesis for the report agent.
Simply asking the synthesis agent to be more careful leaves the overloaded design unchanged. Random parallel partitioning can improve throughput, but concatenating summaries without an integration step risks fluent but inconsistent reporting. Using a fixed iteration limit or citation-count target is also unreliable because those signals do not measure whether the system handled methodological conflicts or caveats correctly.
For more background on breaking complex tasks into focused prompt sequences, see Prompt Engineering and Agent SDK.
Scenario: Developer Productivity with Claude You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate repetitive tasks. It uses built-in tools (Read, Write, Bash, Grep, Glob) and integrates with MCP servers. A senior engineer reports that Claude Code consistently follows your team's codebase exploration notes, legacy module warnings, and boilerplate conventions. New engineers who clone the repository see generic behavior instead, and no repository files changed when the senior engineer originally added those notes.
What is the most effective way to make this guidance consistent for the team?
A
Create a slash command that reminds Claude to apply the conventions whenever developers remember to invoke it.
B
Paste the conventions into the first prompt of each new session instead of changing repository configuration files.
C
Move the shared conventions into a project-level CLAUDE.md file and commit it so every clone loads them.
D
Ask each developer to copy the senior engineer’s personal memory file into their home directory before using Claude Code.
Correct Answer:
C. Move the shared conventions into a project-level CLAUDE.md file and commit it so every clone loads them.
Explanation:
Project-scoped configuration is the right fix when Claude Code behavior must be consistent for everyone working in the same repository. Guidance stored in a project-level CLAUDE.md, such
as .claude/CLAUDE.md or a root CLAUDE.md, can be committed and distributed through normal version control workflows.
The underlying principle is scope alignment: personal preferences belong in user-level memory, while team standards and repository-specific context belong in project-level configuration. If guidance was added locally but no repository files changed, the likely issue is that it was stored in a personal location rather than a shared project file.
Copying personal memory files, relying on optional slash commands, or pasting conventions at session start all create process-dependent behavior and configuration drift. These approaches are fragile because they depend on each developer remembering the same manual steps.
Learn more about Claude Code memory hierarchy and shared project guidance in CLAUDE.md Configuration and the broader Claude Code Overview.
Scenario: Developer Productivity with Claude You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate repetitive tasks. It uses built-in tools (Read, Write, Bash, Grep, Glob) and integrates with MCP servers. Your repository's root CLAUDE.md has grown to 1,200 lines covering testing, API conventions, migration rules, deployment checks, and review norms. Engineers complain that small standards changes cause frequent merge conflicts, and Claude sometimes appears distracted by unrelated guidance. The team wants shared, version-controlled instructions, but needs a more maintainable layout without relying on developers to remember extra steps.
What should you do?
A
Split the guidance into focused topic files under .claude/rules/, such as testing.md, api-conventions.md, and deployment.md.
B
Keep one root CLAUDE.md and add stronger section headings telling Claude to consult only relevant parts.
C
Move the shared standards into ~/.claude/CLAUDE.md so each engineer loads the same instructions outside repository files.
D
Create slash commands for each standards topic and ask engineers to invoke the right command before coding.
Correct Answer:
A. Split the guidance into focused topic files under .claude/rules/, such as testing.md, api-conventions.md, and deployment.md.
Explanation:
Modular Claude Code configuration is the right fit when a shared CLAUDE.md has become too large to maintain effectively. Splitting guidance into topic-specific files under .claude/rules/keeps standards version-controlled while reducing the operational burden of editing and reviewing one monolithic instruction file.
The underlying principle is to keep persistent project context organized by concern. Testing, API conventions, deployment rules, and review norms can evolve independently, making changes easier to review and reducing accidental conflicts between unrelated guidance areas.
Moving instructions into ~/.claude/CLAUDE.md breaks team sharing because that file is scoped to one user. Keeping everything in one root file with stronger headings preserves the monolith and relies on attention management rather than configuration structure. Slash commands are the wrong abstraction because they require manual invocation and are better suited to task-specific workflows, not baseline project standards.
Learn more about Claude Code memory hierarchy and modular configuration in CLAUDE.md Configuration and related Claude Code concepts in Claude Code Overview.
Scenario: Developer Productivity with Claude You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate repetitive tasks. It uses built-in tools (Read, Write, Bash, Grep, Glob) and integrates with MCP servers. A coordinator agent delegates codebase exploration to subagents before asking an implementation subagent to generate migration scaffolding. In reviews, engineers find the final proposal often mixes findings from different packages, cites helper functions without file locations, and cannot explain which search result or source file supports a recommended change. The individual subagents found useful facts, but their handoffs were free-form summaries. What change would best improve downstream reliability while preserving attribution?
A
Require subagents to return structured handoff records with findings separated from file paths, symbols, line ranges, commands, and source excerpts.
B
Strip source details from subagent outputs to reduce context size, then use Grep later when reviewers request justification.
C
Ask the implementation subagent to reread the repository broadly and infer supporting locations from each summarized recommendation before editing.
D
Have each exploration subagent write longer narrative summaries that include reasoning traces and repeated reminders to cite sources.
Correct Answer:
A. Require subagents to return structured handoff records with findings separated from file paths, symbols, line ranges, commands, and source excerpts.
Explanation:
Structured subagent handoffs are the best fit when one agent's findings must be used by another agent for implementation or synthesis. The coordinator should require each exploration subagent to return records that distinguish the discovered fact from metadata such
as file_path, symbol, line_range, source_excerpt, and the command or tool result that produced the observation.
The underlying principle is that subagents operate with isolated context, so any downstream agent only receives what the coordinator explicitly passes along. Free-form summaries often compress away provenance, which makes later recommendations harder to verify and easier to misattribute across similar packages or duplicated helper functions.
Asking a downstream implementation agent to infer locations, adding longer narrative reasoning, or stripping metadata to save space all fail because they treat provenance as optional. In production developer tools, attribution is part of the work product, not decoration, because engineers need to validate recommendations against concrete files and source evidence.
Learn more about subagent orchestration in Agent SDK and Claude Code agent patterns in Claude Code Sub-agents.
Questions: 1-10 out of 678
Continue Full Practice..
GET ALL 678 QUESTIONS