CCDV-F Certification Exam Guide + Practice Questions Updated 2026

Explanation:
Plan mode in Claude
Code is a permission mode for analysis before implementation, not a different
model or subscription tier. It lets Claude inspect the codebase and develop a
plan while avoiding source file edits until the user approves the plan, which
is exactly the control point needed for large migrations and
architecture-sensitive changes.
Anthropic's best-practices guidance recommends planning when the approach is uncertain, when many files may change, or when the developer needs exploration before committing to an implementation path. After Claude presents a plan, approving it exits plan mode and switches into a selected execution mode, such as reviewing each edit manually or accepting edits. For a typo, log line, or simple rename, this checkpoint can be unnecessary, but for a 45-plus-file migration with infrastructure implications, separating planning from editing reduces avoidable churn and makes the architectural decision explicit.
See Claude Code permission modes and Claude Code best practices for the documented behavior and recommended use cases.

Explanation:
Correct retry judgment: Validation
and retry loops should distinguish recoverable extraction mistakes from
missing-source conditions. If the required fact is not present in the supplied
document set, additional retries against the same input cannot recover it and
may produce unsupported values.
Underlying principle: Retry-with-feedback
works for format mismatches, structural placement errors, or semantic
validation issues where the source evidence exists. When the evidence is
absent, the reliable behavior is to mark the extraction incomplete, preserve a
clear reason such asmissing_source, and request the missing document or
route for review.
Why the distractors fail: Arbitrary
retry caps and majority-vote selection can launder hallucinated values into
apparently stable outputs. Required schema fields and inference instructions
can pressure the model to invent facts. Few-shot examples improve recognition
of information that is present, but they cannot compensate for an omitted
source document.
For more on structured outputs, validation, and tool-based extraction patterns, see Tool Use and Prompt Engineering.

Explanation:
The correct control-flow design is to use an agentic loop: send the request to Claude, inspect stop_reason, execute requested tools when the value is tool_use, append matching tool_result blocks to the conversation, and repeat until Claude returns end_turn.
This matters because tool results are not final answers by themselves. In the billing-dispute example, the verified customer record is new context that Claude needs before deciding whether to call lookup_order, process_refund, or escalate_to_human.
Generating a response directly from the first tool payload short-circuits the agent's reasoning. Parsing assistant text for uncertainty is also unreliable because natural language is not a stable lifecycle signal. Arbitrary iteration limits may be useful as guardrails, but they should not replace the explicit stop_reason based termination condition.
For implementation details, see Tool Use and Agent SDK.

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 asfile_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.

Explanation:
Claude Code's Edit tool is designed for targeted exact replacement. Before an edit applies, the file must have been read in the current conversation, the old_string must match exactly, and that string must appear exactly once unless replace_all: true is intentionally used.
When the intended change affects only one occurrence and a unique exact old_string cannot be constructed, the safer fallback is to use the file contents as the source of truth, construct the complete desired final file, and call Write. Write is a whole-file operation, so it bypasses ambiguous substring matching while still requiring care because it overwrites rather than appends or patches.
The tempting alternatives all misuse the tool boundary. replace_all changes every matching occurrence, regex does not apply to Edit, and shorter or looser strings increase ambiguity rather than reducing it. See the official Claude Code tools reference for the documented behavior of Read, Edit, and Write.