CCDV-F Claude Certified Developer-Foundations Question and Answers

The architecture is a manager/supervisor—or orchestrator/subagent—pattern with isolated subagent context. The defining characteristics are a coordinating top-level agent, specialized subordinate agents, delegated responsibilities, and distinct tool/context boundaries. The supervisor determines which specialist should act, sequences work where necessary, and integrates the specialists' outputs into the final result.

Anthropic's published multi-agent research architecture uses this same structural principle. Its Research system employs an orchestrator-worker pattern in which a lead agent analyzes the task, creates specialized subagents, delegates separate research responsibilities, and consolidates their findings. Anthropic emphasizes that good delegation requires each subagent to receive a specific objective, task boundaries, expected output, and appropriate tools.

The question additionally specifies that each travel specialist has its own conversation history and tool list. That eliminates B because context is explicitly not shared globally. C would involve fixed sequential processing rather than supervisor-directed specialization. D describes retrieval augmentation, not autonomous subordinate agents.

Therefore, A precisely matches both the hierarchy and context-isolation characteristics described.

The supplied examination set also marks A as the intended answer. Relevant topics: Agent Patterns, manager/supervisor architecture, orchestrator-worker systems, subagents, delegation, specialized tools, and context isolation.

===============

Option C is correct. Claude Code uses CLAUDE.md as the standard mechanism for supplying persistent project-level instructions and context. Anthropic's Claude Code documentation states that project instructions can be stored in ./CLAUDE.md or ./.claude/CLAUDE.md and shared with team members through source control. Appropriate content includes coding standards, architectural decisions, project conventions, build/test commands, preferred workflows, and information developers would otherwise need to repeat to Claude during every session. The /init command can also generate an initial CLAUDE.md based on the repository.

A wiki may be valuable for human documentation, but Claude Code does not automatically receive that material as project context. B creates developer-specific configuration and risks inconsistency across the team. D places the information in a human-facing README but does not use Claude Code's purpose-built persistent instruction mechanism.

Therefore, C gives the repository a shared, version-controlled source of Claude-specific project guidance. Relevant Study Guide topics: CLAUDE.md, project configuration, persistent instructions, repository context, team standards, and configuration management.

===============

The supplied Claude Developer source explicitly marks A . The scenario contains the defining elements of an orchestrator/subagent architecture : decomposition of a larger objective, delegation of independent subtasks to specialized workers, and aggregation of their outputs by a coordinating agent.

This architecture is appropriate when subtasks can be performed with focused context or specialized tools. Instead of forcing one agent to carry every intermediate detail, the orchestrator can formulate assignments, launch suitable subagents, receive condensed results, identify missing information, and synthesize the final research product. This also enables context isolation and potentially parallel execution.

Anthropic's published multi-agent architecture uses this orchestrator-worker approach for research workloads: a lead agent decomposes a query, delegates work to specialized subagents, and then integrates their findings. This is particularly useful where exploration is broad and individual subtasks benefit from independent context windows. The broader model-selection guidance also identifies orchestrator strategies as useful where work can be partitioned among worker models.

B describes storage rather than delegation. C is a context-management technique, not a decomposition pattern. D centralizes all responsibilities in a single loop.

Relevant Claude Developer topics: Agent Patterns, orchestration, subagents, task decomposition, specialization, delegation, context isolation, and result consolidation .

===============

Option C is correct because Skills and MCP are first-class Claude extension mechanisms intended to make capabilities reusable rather than embedding one-off logic inside a single agent. Claude documentation describes Skills as reusable knowledge, instructions, and workflows that can be loaded when relevant. It describes MCP as the standard mechanism for connecting Claude to external services, tools, prompts, and resources. Claude Code plugins can package Skills and MCP servers for distribution across projects and teams.

Option A tightly couples the capability to one team’s agent and requires copying code, creating version drift and duplicated maintenance. Option B is technically reusable software, but it leaves every consuming Claude application responsible for its own integration and does not expose the capability through Claude’s native extension interfaces. Option D assumes an existing built-in tool is the correct abstraction even though the scenario specifically requires an independently reusable capability.

The precise choice between Skill and MCP depends on what is being reused: use a Skill for reusable instructions/workflows; use MCP when the capability exposes external data or actions. Therefore, C best reflects the Claude Developer extension model. Relevant topics: Agent Skills, MCP, plugins, tool integration, reuse, and cross-team capability distribution.

===============

Option C follows the governing constraint in the scenario: data residency is an enterprise requirement, whereas minimizing infrastructure management is a preference. A deployment architecture cannot knowingly violate a mandatory compliance boundary merely to accelerate delivery. The question should therefore be interpreted under its stated assumption that the described BYOC environment satisfies the enterprise residency policy.

Anthropic's current Managed Agents documentation distinguishes Anthropic-managed cloud environments from self-hosted sandboxes running on infrastructure controlled by the customer. Self-hosting keeps tool execution, files, and network egress within customer infrastructure, although Anthropic documents that model-facing tool inputs and outputs can still pass through its control plane; therefore, actual regulatory approval must be based on the organization's precise data-flow requirements.

B and D explicitly defer or violate the existing policy. A unnecessarily introduces a planned migration away from the residency-compliant architecture without establishing that such a migration would be permissible.

Accordingly, C is the intended certification answer. Relevant Study Guide topics: deployment topology, data residency, self-hosting, compliance constraints, infrastructure ownership, security boundaries, and architecture tradeoffs.

===============

Option B establishes the correct trust boundary. Fluent or confident language is not evidence that a generated claim is factually correct. If downstream systems treat output as authoritative data, the application must independently establish whether the output meets its correctness requirements before accepting it.

Validation can take several forms depending on the workload: compare generated facts against authoritative records, require citations or source references, constrain output to retrieved evidence, apply deterministic business rules, or use separate evaluation/classification stages. Anthropic's agent engineering guidance repeatedly emphasizes explicit evaluation criteria and validation rather than relying on apparent confidence.

A confuses sampling behavior with factual reliability. Lowering temperature does not establish factual correctness and may only make an incorrect answer more repeatable. C supplies maximum oversight but is unnecessarily expensive and removes useful automation even for low-risk, easily validated cases. D communicates uncertainty to users but does not protect downstream systems that automatically consume the response.

Therefore, B treats model output as untrusted until verified to the level required by the application. Relevant Study Guide topics: output validation, grounding, factuality, confidence calibration, source verification, trust boundaries, and downstream safety.

===============

Option B is correct because destructive production operations require deterministic enforcement outside the model’s probabilistic reasoning. Claude Code hooks can intercept lifecycle events before tool execution and explicitly allow, deny, or request further handling based on concrete rules.

Anthropic’s hooks documentation provides this exact security pattern. A PreToolUse hook can inspect a proposed command before execution and return a blocking decision. Anthropic’s example demonstrates blocking destructive operations such as drop table, while other commands proceed normally.

That mechanism can be adapted to database controls: block DROP, destructive DELETE, unauthorized schema modifications, or production writes; require explicit approval for high-risk operations; and allow read-only or known-safe queries automatically.

A merely increases the probability that someone might notice an unsafe operation and does not prevent execution. C assumes model capability can replace access controls, which is an unacceptable safety boundary. D is useful behavioral guidance but remains probabilistic and cannot guarantee prevention.

Therefore, B creates a deterministic control between model intent and side-effect execution. Relevant Study Guide topics: Claude hooks, PreToolUse, tool governance, deterministic enforcement, approval gates, least privilege, and destructive-operation protection.

===============

The supplied Claude Developer item selects A . The symptoms—duplicated logic, tangled control flow, and increasing difficulty adding features—indicate accumulated technical debt in a component that has become structurally difficult to change. Because the problem is already materially reducing development velocity, deliberate refactoring should occur before additional feature pressure compounds it.

The objective is behavioral preservation with structural improvement. Duplicated prompt construction should be consolidated where the behavior is genuinely shared. Prompt preparation, configuration, API invocation, validation, error handling, and post-processing should have clear responsibilities. Control flow should be simplified so each stage is testable independently. Existing tests should first capture important current behavior so refactoring can proceed without silently changing application semantics.

B can be appropriate for minor cleanup, but the question describes broad systemic complexity. Mixing substantial structural refactoring into unrelated feature tickets makes scope, review, and regression analysis harder. C knowingly allows the debt to compound. D centralizes complexity rather than removing it and violates separation of concerns.

Relevant Claude Developer topics: SW Eng Foundations, refactoring, technical debt, DRY, separation of concerns, maintainability, modular design, regression testing, and control-flow simplification .

===============

Option A correctly applies selective enforcement. Claude Code hooks can execute automatically at lifecycle events such as PreToolUse, and matchers or conditions can narrow exactly which operations trigger a hook. Anthropic’s hook reference demonstrates this pattern by applying a PreToolUse hook specifically to destructive shell operations rather than indiscriminately processing every command. The documentation notes that if the matcher or conditional expression does not match, the handler is skipped, avoiding unnecessary process-spawn overhead.

That architecture is particularly appropriate for costly or security-sensitive checks. High-risk events—destructive file operations, privileged commands, production changes, or access to sensitive resources—can receive deterministic pre-execution enforcement while routine low-risk actions proceed without additional hook latency.

B creates an avoidable period in which safeguards disappear entirely. C reduces application availability without addressing the actual source of overhead. D is technically weaker because system-prompt instructions influence model behavior but are not equivalent to deterministic lifecycle interception capable of blocking execution.

Therefore, hooks should be scoped using event types, matchers, and conditions according to risk. Relevant Claude Developer topics are Claude Code hooks, agent construction, tool governance, deterministic controls, permission boundaries, safety/performance tradeoffs, and lifecycle interception.

===============

Option D precisely matches Anthropic's SDK behavior. Official SDK documentation states that transient conditions are automatically retried two times by default with exponential backoff. The default retry set includes connection failures, HTTP 408 Request Timeout, 409 Conflict, 429 Rate Limit, and 5xx server errors. Developers can alter or disable this behavior through the SDK's retry configuration.

This directly eliminates A because the retry count is configurable. B is incorrect because rate-limit responses are among the conditions automatically retried by the supported SDKs; the API also provides retry-after information where applicable. C is incorrect because the SDK does not merely log these failures and continue without attempting recovery.

Application-level handling is still necessary after the configured retry policy is exhausted. Production code should distinguish permanent errors from transient failures, preserve request IDs for diagnostics, and decide whether higher-level fallback, queuing, or user-visible failure handling is appropriate.

Therefore, D correctly characterizes the SDK abstraction: useful retry defaults combined with developer control. Relevant Study Guide topics: Claude SDKs, transient errors, HTTP 429, retries, exponential backoff, configuration, and resilient API integration.

===============

Option B is the correct automation pattern. A CI pipeline must operate non-interactively, so Claude Code should be invoked in its programmatic/headless execution mode and given only the permissions required for the predefined workflow. Output can then be captured by the pipeline and supplied to subsequent build, testing, reporting, or deployment stages.

Claude Code's configuration system supports explicit permission rules in JSON settings. Anthropic documents that settings.json controls, among other behavior, what Claude Code can execute without asking. For example, permissions.allow can authorize specific commands while permissions.deny prevents sensitive operations. Project-level .claude/settings.json can be version-controlled so CI behavior is reproducible across runners.

This is substantially safer than C, which disables confirmation behavior globally and expands the blast radius beyond the CI workload. D defeats automation because a human must remain present. A is unnecessary because Claude Code is explicitly configurable for automation scenarios.

The principle is least-privilege non-interactive configuration: authorize only the commands and resources required by the pipeline and capture machine-readable output for downstream processing. Relevant Claude Developer topics are Claude Code automation, configuration management, permissions, CI/CD integration, headless execution, and reproducible project settings.

Option B is the intended and technically correct answer. The supplied Claude Developer exam source selects streaming responses. Streaming allows the client application to begin receiving output before generation of the complete message has finished, reducing perceived latency for interactive user experiences.

Anthropic's official Messages API documentation states that setting stream: true causes responses to be delivered incrementally through Server-Sent Events (SSE) . Claude can stream text deltas as well as other event types, including structured tool-use and extended-thinking events where applicable. Anthropic's SDKs provide corresponding synchronous or asynchronous streaming helpers.

The application consumes events as they arrive, updates the UI progressively, and then handles the final event or stop reason when generation completes. This architecture is particularly useful for chat interfaces and other latency-sensitive interactive experiences.

A addresses output structure, not progressive transmission. C is designed for asynchronous, throughput-oriented processing rather than immediate user interaction. D reduces processing cost and latency for repeated prompt prefixes but does not itself turn a response into an incremental stream.

Relevant Claude Developer topics: Messages API, streaming, SSE, incremental tokens, latency, event handling, interactive applications, and API response mechanics .

===============

Option A is correct because sensitive-data protection must occur before prohibited information crosses the application's trust boundary. If account numbers, passwords, or other secrets must not be sent to Claude, asking Claude to “ignore” those values after transmission does not satisfy the requirement. The application must determine which data is permitted to leave its controlled environment and transform or reject prohibited content before constructing the Claude request.

This principle is consistent with Anthropic's defense-in-depth guidance. Anthropic recommends input screening, limiting Claude's access to sensitive information, and applying least privilege so the model receives only information necessary for the task.

B is fundamentally too late: the sensitive information has already been transmitted to the model context before the system instruction can influence behavior. C is worse because logging can create an additional store containing the sensitive information and only detects exposure after it occurs. D implements some boundary filtering but deliberately leaves coverage incomplete until production incidents reveal additional patterns.

Therefore, A requires the boundary and its permitted data flows to be defined first, then enforced comprehensively through filtering, redaction, tokenization, or rejection. Relevant Study Guide topics: application boundaries, data minimization, sensitive-data handling, filtering, redaction, least privilege, and privacy-preserving design.

===============

Option C applies the appropriate context-management technique. The issue is not simply whether the older conversation can physically fit into the context window; it is that stale details remain prominent enough to interfere with the model’s current task. Effective context engineering optimizes signal quality, not merely maximum token retention.

Anthropic’s context-editing documentation describes compaction as summarizing accumulated history and replacing the full history with a structured summary when context becomes large. This preserves important task state while substantially reducing low-value detail that can distract later reasoning.

A retains precisely the stale material producing the problem and therefore does not address context drift. B destroys all useful continuity between turns, including valid goals, decisions, and intermediate state. D is similarly excessive because limiting Claude to only the latest turn discards information that may still be required.

Compaction provides the correct middle ground: retain durable conclusions, current objectives, unresolved issues, and other high-signal state while compressing obsolete conversational detail. Relevant Study Guide topics: context engineering, compaction, conversation history, long-running agents, stale context, context drift, and high-signal state preservation.

===============

Option B establishes a layered testing strategy rather than relying on a single testing granularity. Unit tests validate deterministic functions and isolated components quickly. Integration tests verify boundaries between application code and Claude-related components such as API clients, tool execution, parsing, persistence, and error handling. End-to-end tests then validate the most important user workflows across the complete application stack.

This separation is particularly useful for Claude applications because deterministic software failures and probabilistic model-quality failures should not be treated identically. Anthropic's evaluation guidance recommends defining specific, measurable success criteria and constructing representative test cases to determine whether model behavior meets those criteria. These evaluations complement conventional software tests rather than replacing them.

A focuses exclusively on test-driven development; TDD can be valuable but does not define all required test levels. C preserves the existing ad-hoc methodology rather than establishing a repeatable quality strategy. D overuses expensive and slower end-to-end tests while omitting the faster diagnostic value of unit and integration tests.

The supplied exam source marks B as correct. Relevant topics: SW Eng Foundations, test strategy, unit testing, integration testing, end-to-end testing, Claude evaluations, regression coverage, and production reliability.

===============

Production deployment does not terminate the software lifecycle. Once a Claude application is actively serving users, it enters an operations and maintenance phase in which developers and operators monitor performance, evaluate model behavior, respond to failures, control costs, manage security, and evolve the implementation as requirements or model capabilities change.

Anthropic's official developer documentation explicitly separates the journey into build, evaluate-and-ship, and operate stages. The operating stage includes workspace administration, API-key management, usage monitoring, and model migration. This confirms that production deployment is a transition into ongoing operation rather than the endpoint of development.

For LLM applications, maintenance is especially important because production traffic can expose input distributions and failure modes that were not fully represented during pre-release evaluation. Operational data should feed back into evaluations, prompt improvements, guardrails, architecture decisions, and model-version planning.

A incorrectly treats deployment as final. B may be useful but is only one governance activity, not the overall lifecycle phase. D assumes a mandatory organizational separation that is neither required nor generally desirable.

The supplied exam source marks C. Relevant topics: Systems Life Cycle, production operations, monitoring, maintenance, incident response, evaluation, and continuous system evolution.

===============

Option B is correct. A large prompt containing overlapping, contradictory, or obsolete instructions creates instruction ambiguity and increases the likelihood that Claude will apply an unintended rule, over-weight irrelevant guidance, or produce inconsistent behavior.

Anthropic's current prompting guidance reinforces this principle: Claude performs best when instructions are clear, explicit, and direct. Prompt design should minimize ambiguity and provide the model with precisely the context and behavioral requirements needed for the task. Refactoring should therefore remove obsolete requirements, consolidate duplicated instructions, resolve contradictions, and establish one authoritative formulation for each behavioral rule. The revised prompt should then be regression-tested against representative inputs.

A makes an already overloaded prompt larger and relies on instruction ordering instead of eliminating conflicts. C addresses only one defect while retaining redundant and obsolete material. D does not inherently solve contradictions and may fragment authoritative instructions across multiple locations.

Therefore, B addresses the root cause. Relevant Study Guide topics: system prompt design, prompt maintainability, instruction clarity, conflicting instructions, prompt refactoring, regression evaluation, and context quality.

===============

D is the only option that addresses all three identified production-readiness defects. The supplied Claude Developer item explicitly selects D. A functioning happy path is insufficient for a maintainable Claude integration.

Prompt and model selection are configuration concerns that will change as prompts are evaluated, model versions evolve, or environments require different behavior. They should therefore be separated from unrelated business logic rather than scattered as inline constants. Claude API failures must also be handled deliberately. Anthropic documents typed SDK exceptions and defined HTTP error categories, including invalid requests, authentication failures, rate limits, server errors, overload, and timeouts. The official SDKs additionally retry appropriate transient failures.

Tests are required to verify the integration boundary, including successful behavior, malformed or unexpected responses, API error handling, and critical user workflows. Approving code without those controls pushes known reliability debt directly into production.

A and B knowingly merge incomplete production behavior. C improves configuration and test coverage but leaves a known API-failure path unhandled.

Relevant Claude Developer topics: SW Eng Foundations, code review, separation of configuration, error handling, integration testing, API resilience, maintainability, and production readiness .

===============

The correct response is iterative prompt improvement backed by evaluation , making A the appropriate choice. The supplied Claude Certified Developer Foundations material explicitly selects A. When production input distribution changes, a prompt that previously met requirements can become inadequate. The correct engineering response is not to preserve the prompt merely because it once worked; prompts are application components that should evolve with observed workload behavior.

Anthropic's official evaluation guidance describes prompt development as a cycle involving test cases, an initial prompt, iterative testing and refinement, final validation, and deployment. Success criteria should be specific and measurable, and evaluations should include representative cases that expose known failure modes.

The underperforming category should therefore be incorporated into the evaluation set. The team can modify instructions, examples, context organization, or other prompt components, then compare the revised prompt against both the newly important category and existing common cases. This prevents improvement in one segment from silently producing regressions elsewhere.

B avoids the defect instead of correcting it. C risks degrading previously successful behavior. D creates unnecessary architectural fragmentation.

Relevant Claude Developer topics: prompt iteration, evaluation-driven development, regression testing, representative test sets, prompt optimization, and production feedback loops .

===============

Option B is the appropriate software-engineering communication pattern when the application requires a persistent, low-latency, bidirectional channel. WebSockets establish a connection using an HTTP Upgrade handshake and then maintain a TCP-based communication channel in which either side can send messages independently. This eliminates the repeated connection setup and request overhead associated with conventional polling.

RFC 6455 defines WebSocket specifically as a protocol enabling two-way communication and explains that it provides a single TCP connection as an alternative to HTTP polling for interactive communication.

Option A can work for infrequent updates, but repeatedly opening HTTP requests adds latency, headers, and server/client overhead and is unsuitable when continuous real-time communication is the stated requirement. C resembles long polling or an ad-hoc streaming connection but lacks the standardized framing, lifecycle behavior, and interoperability provided by WebSocket. D introduces filesystem polling and is not an appropriate network-streaming architecture.

The important certification principle is selecting a communication mechanism based on application requirements rather than merely choosing an available protocol. For persistent two-way streaming, WebSocket provides the intended abstraction. Relevant Claude Developer topics are software engineering foundations, client-server communication, persistent connections, HTTP versus WebSocket patterns, streaming, and real-time application architecture.

===============

Option B is the best answer because the task requires deliberate multi-step reasoning over competing hypotheses before a final recommendation. Anthropic’s thinking documentation explains that enabling thinking gives Claude additional reasoning capacity before producing the final response, and larger thinking budgets can improve performance on complex analytical tasks. That maps directly to a differential-diagnosis workflow involving evidence comparison, hypothesis elimination, and multi-stage synthesis.

Option A uses ordinary zero-shot prompting and does not specifically allocate additional reasoning capacity. Option C explicitly optimizes for minimum latency at the expense of reasoning depth, which conflicts with the complexity requirement. Option D reduces model and context capacity and therefore has no principled relationship to better differential reasoning.

One current-platform nuance is important: manual “extended thinking” is the legacy configuration on supported Claude 4.5/4.6 models, while newer models use adaptive thinking. That does not change the question’s underlying answer: among the listed choices, B is the only option that intentionally provides a reasoning phase for complex analysis. Relevant Study Guide topics: thinking, reasoning budgets, complex-task model configuration, latency-quality tradeoffs, and model selection.

===============

Option D applies a fundamental production engineering principle: treat externally generated data as potentially malformed and parse it defensively before use. Downstream application logic should not assume that every field exists, every type is correct, or every unexpected property can safely be ignored. Instead, the parser should validate expected structures, handle optional or missing values deliberately, reject incompatible types, and convert failures into controlled application errors rather than process crashes.

Anthropic's Structured Outputs documentation identifies exactly these failure classes for unconstrained model output: malformed JSON, missing required fields, inconsistent types, and schema violations can break downstream applications. Current Structured Outputs and strict tool-use capabilities can eliminate many schema-level failures through constrained decoding, but defensive handling remains an important software boundary when unexpected data can still arise from external services, legacy paths, or semantic validation requirements.

A creates unnecessary outages. B hides failures and discards potentially recoverable data without observability. C deliberately postpones a reliability requirement until after deployment.

The supplied question identifies D as correct. Relevant topics: Claude App Design, defensive programming, structured output, schema validation, parsing, error handling, downstream reliability, and type safety.

===============

Option A provides proper environment isolation and credential blast-radius control. Development, staging, and production represent different trust boundaries and should not share the same API credential. If a development machine, CI job, or staging service is compromised, a distinct credential prevents the attacker from automatically gaining the same access to production.

Anthropic's official workspace documentation explicitly recommends using separate workspaces for development, staging, and production. Workspaces can have their own API keys, members, resource limits, and usage tracking, and keys can be scoped to a specific workspace. Anthropic's authentication guidance also instructs developers to store API keys in a secrets manager, rotate them periodically, revoke suspected compromised keys, and use workspaces to scope credentials by project or environment.

B confuses rotation with isolation: rotating a credential that remains shared across all environments does not create independent security boundaries. C deliberately increases blast radius. D merely substitutes one globally shared key for another and therefore has the same architectural flaw.

The supplied exam source marks A as correct. Relevant topics: Confia Management, secrets management, API-key scoping, environment isolation, credential rotation, workspaces, least privilege, and production security.

The question presents a trust-boundary failure: model-generated tool arguments are being accepted without sufficient validation before an external operation executes. A tool call should therefore be treated like input arriving at any typed application interface—the application must ensure that the tool name and arguments satisfy the declared contract before dispatch.

Anthropic describes tool use as a contract in which the application defines the tool's schema and Claude returns structured tool_use input. Current Claude functionality also supports strict: true, which guarantees schema-compliant tool inputs through constrained generation and specifically addresses invented parameters, incompatible types, and missing required fields. For applications not using strict tool use, explicit application-side validation and a controlled error path remain essential.

B knowingly executes invalid input. C relies on uncontrolled repetition rather than deterministic validation and bounded recovery. D eliminates a useful capability instead of correcting its execution boundary.

Therefore, A provides the correct defensive design. Relevant Study Guide topics: tool calling, tool_use, input_schema, strict tool use, schema validation, defensive execution, error handling, and secure tool dispatch.

The supplied Claude Developer examination source selects A . The purpose of choosing an agent SDK rather than implementing a custom Messages API loop is to consume the SDK's higher-level abstractions. Re-implementing dispatch, iteration, and state handling would discard much of the value provided by the SDK.

Anthropic's current documentation distinguishes low-level tool-use loops from higher-level SDK-managed abstractions. With a manually implemented Messages API workflow, application code must inspect stop_reason, execute requested client tools, append tool_result blocks, preserve conversation history, and repeat until Claude completes the turn. Anthropic's higher-level tooling can instead encapsulate this repetitive control flow. Current migration guidance also confirms that Agent SDK @tool functions are automatically dispatched by the SDK and that agents, tools, and sessions are first-class SDK concepts.

B is incorrect because structured tool use should not be replaced with informal plain-text calls. C introduces an unnecessary custom state dependency when no external persistence requirement exists. D duplicates control-loop functionality despite the explicit decision to use the SDK.

Relevant Claude Developer topics: Agent SDK, tool definitions, dispatch, agentic loops, conversation state, tool execution, and abstraction selection .

===============