Welcome to awslagi.com – Sharing AWS, Google Cloud, Microsoft Azure IT Exams. It's free for all!

Claude Certified Developer — Foundations

Master Claude Certified Developer — Foundations (CCDV-F) with hands-on practice in Claude API integration, MCP servers, agents, and Claude Code.

4.8★★★★★(263 ratings)
20,773 studentsIntermediate
Accelerate your AI engineering skills for the Anthropic Claude Certified Developer — Foundations (CCDV-F) exam. Practice building production applications using the Claude API, designing robust tools and Model Context Protocol (MCP) servers, and implementing agentic workflows. You will also strengthen your skills in prompt and context engineering, security and safety guardrails, model optimization, and automated testing and debugging with Claude Code. Perfect for developers building reliable, high-performing Claude applications.

What you'll learn

  • Tools, Function Calling & MCP Integration
  • Prompt & Context Engineering for Developers
  • Agents, Workflows & Applications Integration
  • Security, Safety & Model Optimization
  • Claude Code, Evaluation & Debugging

CCDV-F

Lectures1
Questions27
Duration30 week
Students20,773

$20.00

Full Free Question Bank (27 Questions)

Claude Certified Developer — Foundations (CCDV-F) Practice Questions & Verified Answers

Click any option to test your knowledge, or reveal the verified answer and detailed explanation below each question.

Question #1Part 1Security and Safety

Your Claude application's content policy defines categories of content that it must never produce under any circumstances. The application currently has no way to enforce this policy, and content in these categories is appearing in its output. How would you enforce the content policy?

AEnhance the system prompt to contain explicit instructions for the categories to avoid, complete with examples of each category. Treat the strengthened prompt as the primary enforcement mechanism for the application’s content policy across all responses.
BRemove the content policy entirely and let any output reach users during normal operation, accepting whatever content the application produces in response to incoming traffic.
CAdd deterministic output filtering that checks responses against the content policy before they reach users.
DMove enforcement to users by asking them to report content policy violations after the violating content has already reached them in the application’s responses.
Question #2Part 1Security and Safety

Your Claude application’s API keys are kept in a secrets manager. The team is considering whether to use the same key in development, staging, and production. How should the keys be handled across environments?

AUse a single development key everywhere on the grounds that production keys are too risky to deploy across the application's three environments during normal operation.
BUse distinct keys for each environment so a compromise in one environment does not affect the others during normal operation across the application’s lifecycle.
CRotate the same key across environments at random intervals on the grounds that random rotation provides isolation between environments without requiring distinct keys.
DUse the same key across all environments for simplicity and treat the propagation of any compromise as a known operational tradeoff for the team's key management approach.
Question #3Part 1Tools and MCPs

The team is considering whether to implement a new capability as a custom tool or use an existing built-in tool that almost meets the use case but is missing one specific feature. How should you make the decision?

AReview the built-in tool’s documentation and assess whether its existing capabilities are sufficient to cover the use case without any modification or extension.
BIdentify whether the team has previously built similar custom tools and use those precedents to determine which approach is more consistent with the existing codebase.
CExamine the custom tool option by scoping the implementation effort and determining whether the additional flexibility justifies the development and maintenance cost.
DEvaluate whether the missing feature can be addressed by extending the built-in tool or warrants a custom tool, then choose accordingly.
Question #4Part 1Tools and MCPs

A teammate has asked for an explanation of when a Skill is the better choice than an MCP server. The teammate is unsure how the two differ in practice when both can be reused across teams. How would you describe the distinction?

AA Skill is preferable for cross-team reuse because it loads more efficiently than an MCP server during normal operation in the team’s typical multi-team workloads.
BA Skill bundles prompts, scripts, and data into a package the model loads as a unit while a MCP server exposes resources, tools, and prompts through a standard client interface.
CA Skill and an MCP server are equivalent extension mechanisms that the team can use interchangeably for any reusable capability that needs to be accessible across teams.
DA Skill is the older mechanism and an MCP server is the newer one, so the team should prefer an MCP server for any reusable capability that the team builds going forward.
Question #5Part 1Prompt and Context Engineering

You are creating a system prompt for a Claude application that must generate output in a particular JSON shape. The downstream system will reject any output that fails to conform to the schema. Your prompt would need to ...

Aomit any reference to the format and rely on a post-processing step in the application to reshape Claude’s output.
Binstruct Claude to return JSON sometimes and free text other times so the application's output captures both formats.
Cinclude explicit constraints describing the required JSON schema and an instruction to produce only output matching that schema.
Dinstruct Claude to use whichever output format it considers most appropriate for each request the application handles.
Question #6Part 1Prompt and Context Engineering

Your Claude application generates good responses for typical inputs but has difficulty with edge cases. You have several labeled examples of edge-case inputs and the desired response for each. You want to use these examples to improve the model’s treatment of edge cases. What is the best way to use these examples?

AEmbed the examples in a database for the model to find during inference.
BTrain a custom model on the edge-case examples and deploy that custom model in place of the team’s current Claude integration.
CAdd the labeled edge-case examples to the prompt as few-shot examples so the model can learn the pattern.
DTell users to avoid submitting the edge-case inputs to the application by adding warnings in the application’s user interface.
Question #7Part 1Applications and Integration

Your Claude application validates structured output, but it has been treating validation failures as terminal errors. Every validation failure makes the entire user request fail. The team wants to handle validation failures more gracefully. How would you handle the validation failures?

ATell users that validation failures are unavoidable and instruct them to perform manual accuracy checks before relying on outputs.
BDisable output validation until the underlying cause of validation failures has been identified and addressed in a future release.
CTreat validation failures as a recognized error path that triggers retry, repair, or fallback logic before failing the user request.
DPass validation failures directly to downstream systems and let each downstream system decide how to handle the malformed output.
Question #8Part 1Agents and Workflows

You are designing an agent to manage a complex claim-processing workflow. Each claim proceeds through fact extraction, eligibility evaluation, and a decision step. The three subtasks have separate success criteria, and some claims need iteration between fact extraction and eligibility evaluation before a decision can be made. Which agent pattern would you use?

AA single tool-use loop pattern that gives one agent access to all the tools needed for fact extraction, eligibility evaluation, and decision-making.
BA graph-based pattern that lets the agent move between subtasks based on the state of each claim, with each subtask evaluated against its own criteria.
CA linear chain pattern that processes every claim through fact extraction, then eligibility evaluation, then decision, with no return paths between subtasks.
DA streaming pattern that emits partial decisions as the agent processes each claim, refining the output until a final decision emerges from the stream.
Question #9Part 1Applications and Integration

The Anthropic API has deprecated a request parameter that your Claude application uses in approximately 40 locations across the codebase. The deprecation notice provides a six-month window before the parameter is removed and recommends a replacement parameter with slightly different semantics. You would address the deprecation by ...

Aswapping all 40 call sites in a single change right away to prevent drawn-out migration work that will delay ongoing functioning.
Bmigrating all 40 call sites in a single change near the removal date to ensure the deprecated parameter continues to work as long as possible.
Cadding regression tests to cover the parameter’s behavior, then migrating call sites in batches that you validate against regression tests.
Dkeeping the deprecated parameter in place while writing a wrapper function around it to insulate the rest of the codebase from the eventual change.
Question #10Part 1Applications and Integration

A Claude application uses structured output that downstream code consumes. The team wants to gracefully handle malformed or unexpected output so that it does not crash downstream systems. The best option for addressing this issue is to ...

Ause the output the model produces and leave schema enforcement to a later phase of production after the application is more complete.
Bapply defensive parsing to handle unexpected fields, missing values, and type mismatches that the downstream code might otherwise crash on.
Ccrash on any unexpected output and require manual recovery on affected requests the application handles during normal operation.
Dsilently drop any output that does not match expectations so downstream systems do not see the malformed output the application receives from the model.
Question #11Part 1Tools and MCPs

A teammate asks why your Claude agent’s tool definitions contain detailed descriptions even though the tool names are already descriptive. They propose removing those descriptions to make the tool definitions simpler. How would you reply?

AAgree with the teammate because tool names are sufficient for the model to choose the right tool on every request the agent handles.
BExplain that the model uses the tool description to decide when to call the tool, and descriptions disambiguate cases where the tool name is not enough.
CSuggest moving the descriptions out of the tool definition and into a separate documentation file the team maintains so the tool definitions stay short and the descriptions remain available.
DSuggest replacing the descriptions with example calls embedded in the tool definition, treating example calls as a complete substitute for the prose description.
Question #12Part 1Prompt and Context Engineering

You are designing a Claude application that requires structured JSON output for downstream processing. The output schema is clearly defined, and downstream systems will reject malformed JSON. Your application design would ...

Aavoid structured output and use free-form text everywhere instead, on the grounds that free-form text is more flexible and handles edge cases better than structured schemas.
Bstructure the prompt to request output in a schema that is described in plain English, with downstream systems parsing whatever shape Claude produces.
Cdefine a clear schema and structure the prompt to request output in that schema, with downstream systems handling any validation needed.
Ddefine a clear schema, structure the prompt to request output in that schema, and validate Claude’s output against the schema before passing it downstream.
Question #13Part 1Prompt and Context Engineering

Your Claude application processes 50-page legal contracts and generates summaries with citation references to the source. The team is considering whether to send each contract as a whole or divide it into smaller pieces. The contracts fit within Claude’s context window. Initial testing indicates that whole-document processing produces summaries with better cross-section reasoning, but citation accuracy occasionally drifts in later sections. Chunked processing yields stronger citation accuracy for each chunk but loses cross-section reasoning. The team has not yet decided which property is more important. How would you guide the team’s decision?

AAssess the cost and latency implications of both approaches against the application’s performance requirements before recommending which processing strategy to adopt.
BExamine the use cases where cross-section reasoning failures occur and assess whether whole-document processing meets the application’s accuracy requirements across a representative sample of contracts.
CReview the citation accuracy results from chunked processing and determine whether the loss of cross-section reasoning produces summaries that still meet the application’s quality bar.
DIdentify which property matters more for the application’s actual use case and let that decision drive the chunking approach, then validate the choice against representative contracts.
Question #14Part 1Model Selection and Optimization

A teammate has asked you to explain why the team’s Claude application is charged a different rate for output tokens than for input tokens. They had assumed that the two rates were identical. How would you explain the difference?

AOutput tokens are typically billed at a higher rate than input tokens, and cost models for the application should reflect both rates separately.
BOutput tokens are typically billed at the same rate as input tokens, and the apparent rate difference is a billing error to report to Anthropic.
COutput tokens are typically billed at a lower rate than input tokens, because output tokens are cheaper to produce than input tokens are to process.
DOutput tokens are not billed at all, because cost is determined entirely by the input tokens sent to the model on each request.
Question #15Part 1Prompt and Context Engineering

You are designing a multi-step Claude workflow in which certain steps must reason without viewing the complete preceding conversation history. The team wants to keep particular context isolated to particular steps. The context-engineering technique to use is ...

Acontext isolation through subagents or multi-step agentic workflows that scope each step’s context to only what the step needs.
Busing a single global prompt that applies to every step in the workflow no matter what each step is reasoning about during its run.
Cembedding the full prior history in each step regardless of whether the step needs the prior history for its reasoning.
Daugmenting the context with all available content at every step so each step has access to the entire prior history of the workflow during its reasoning.
Question #16Part 1Security and Safety

A teammate is reviewing the team’s threat model for a Claude application and has asked you to identify the AI-specific threat categories the model should cover. The teammate has already listed traditional web-application threats and wants to know which additional categories apply to a Claude application. Which AI-specific threat categories would you add?

ASupply chain attacks on the Claude SDK because the SDK itself is the only point of vulnerability that a Claude application introduces beyond traditional web application threats.
BNetwork-level denial of service and physical infrastructure attacks, because these categories cover the threats most likely to affect any Claude application in production.
CCross-site scripting and SQL injection, because these traditional web application threats apply with equal weight to any application that uses Claude in any way.
DPrompt injection, data leakage from prompts or context, jailbreak attempts, and unsafe model output that bypasses application controls.
Question #17Part 1Tools and MCPs

A Claude agent can access a tool that retrieves customer records. A teammate observes that the agent sometimes invokes the tool with arguments not declared by its schema, causing the downstream service to return an error each time. The teammate suggests loosening the schema so the tool accepts any arguments the model generates. How would you respond?

ARemove the schema entirely and rely on the downstream service to reject invalid calls, treating the downstream service as the team’s primary enforcement layer.
BLoosen the schema as the teammate proposed so the downstream service receives every call the agent makes during normal operation.
CAdd a system prompt instruction telling the model to produce schema-conforming arguments, treating the prompt instruction as the primary mechanism for keeping the agent’s tool calls valid.
DKeep the schema strict, validate arguments before dispatching, and return a structured error so the agent can retry.
Question #18Part 1Claude Code

Your Claude agent’s hooks currently fire for every action, substantially slowing the agent even when the actions present no risk. The team wants to scope the hooks more precisely. How should you scope the hooks?

AReplace hooks with system prompt instructions on the grounds that prompt instructions can produce the same enforcement effect that hooks produce on the agent’s actions.
BScope hooks to only the high-risk actions, such as destructive operations or sensitive data access, and remove hooks from low-risk actions to balance safety with performance.
CDisable all hooks while the team re-scopes them, treating the period of no hook enforcement as a temporary state during the re-scoping work.
DDisable the agent during peak hours so the hook overhead does not slow the application down during the busiest periods of the day across the application’s operation.
Question #19Part 1Agents and Workflows

You are designing an agent for a multi-step research task. You want it to divide the task into smaller parts, delegate each part to a specialized subagent, and consolidate the results. The agent pattern to apply is ...

Aa single tool-use loop that includes every tool the agent might need across all subtasks.
Ban orchestrator and subagent pattern with specialized subagents assigned to each subtask.
Ca memory pattern that stores the entire research history in advance, before any subtask begins execution.
Da context-window pruning pattern that drops each subtask’s content after the agent moves on.
Question #20Part 1Agents and Workflows

You are creating an agent that must call multiple internal APIs and a database in a structured, repeatable manner. Your team has chosen the Claude Agent SDK instead of building a custom loop. You are configuring the agent’s tool definitions and execution loop. How should you configure the tools and execution loop?

ACall the Messages API directly and let the model format its tool calls in plain text.
BUse the SDK’s tool interface and loop, with conversation history stored in a separate team database.
CUse the SDK’s tool interface and let the SDK handle the loop, dispatch, and history.
DUse the SDK’s tool interface and write the loop and history layer in the team’s own code.
Question #21Part 1Applications and Integration

Your team’s Claude agent has built up several customizations that bypass the SDK defaults, including custom history management, retry logic, and error handling. A new team member proposes reverting every customization to make the codebase easier to maintain. The tech lead disagrees, stating that each customization was introduced for a reason. What would you advise the team?

ARevert all customizations to the SDK’s defaults to standardize the codebase.
BDecide on each customization individually based on its original reason and the SDK’s current capabilities.
CKeep all customizations, trusting that the tech lead’s original reasoning is still valid.
DMigrate the agent off the SDK and rebuild it with a custom loop.
Question #22Part 1Eval, Testing, and Debugging

Your team’s Claude application has been in production for one year, and the team has chosen to formalize its testing strategy. At present, the team writes ad-hoc tests for individual features but lacks an overall testing approach. Which testing approach should be formalized?

AAdopt a test-driven development practice where unit tests are written before each feature is implemented and must pass before code is merged.
BDefine unit tests for individual functions, integration tests for the Claude integration, and end-to-end tests for critical user flows, applied consistently across the codebase.
CContinue writing ad-hoc tests as features ship and introduce a peer review step to ensure each test adequately covers the feature being released.
DDefine a single testing approach that uses end-to-end tests and apply it consistently across all new features as they are added to the codebase.
Question #23Part 1Eval, Testing, and Debugging

A teammate submitted a pull request that introduces a Claude-powered feature to your service. The code functions, but its prompt and model choice are hard-coded inline, it lacks error handling, and there are no tests for the integration. What would you request in code review?

ARequest changes that move prompt and model configuration to a configurable location, add error handling for Claude API failures, and add tests for the integration.
BRequest changes that move prompt and model configuration to a configurable location and add tests, treating the missing error handling as a follow-up release item.
CApprove the pull request and add the missing pieces yourself in a follow-up commit so the teammate can move on to other work immediately.
DApprove the pull request as-is, on the grounds that the feature works in the happy path and the missing pieces can be added in follow-up commits.
Question #24Part 1Prompt and Context Engineering

A teammate asks why your Claude application sometimes returns a response that repeats the prompt text, while at other times it rephrases that prompt text. They suspect there is a bug in the application’s request construction. How would you respond?

AExplain that LLMs generate output token by token, and variation in how prompt content appears in output is a property of generation, not a bug in request construction.
BConfirm that the variation is a bug in the application’s request construction and start investigating which part of the application is producing the inconsistent prompt text.
CTell the teammate that the variation depends on which Claude model serves the request, and recommend pinning the application to a single model version to make the output behavior consistent.
DTell the teammate that the variation is caused by the application sending two different prompts on different runs and propose a code change that pins the system prompt to a single version.
Question #25Part 1Applications and Integration

The team is considering whether to integrate with the Claude API directly or via a third-party abstraction layer that supports multiple LLM providers. The team has determined that all current and anticipated use cases run on Claude, no internal customer has asked for LLM portability, and the product roadmap contains no multi-provider support over the next two years. The third-party abstraction would add about 15 percent overhead in code complexity and introduce an additional dependency. Which integration approach would you recommend?

AThe third-party abstraction layer, on the grounds that multi-provider support is valuable for any application as a matter of long-term flexibility across vendors.
BDirect integration with Claude through its SDK, because no multi-provider need exists and abstraction would add complexity that does not pay off.
CA custom multi-provider abstraction layer the team builds in-house so that the team controls every part of the abstraction the application uses for its API calls.
DBoth integration paths in parallel, where the application uses each path on different runs to compare which performs better in production over time.
Question #26Part 1Agents and Workflows

You are examining an architectural diagram for a Claude-powered travel-booking system. It depicts a top-level component that interprets user requests and three subordinate components responsible for flights, hotels, and ground transportation. The top-level component routes each request, sequences the subordinate components, and reconciles their outputs into a final itinerary. The diagram also indicates that every subordinate component has its own tool list and its own short conversation history, neither of which is shared with the others. Which architectural pattern does this diagram most closely represent?

AA manager and supervisor pattern with shared context, where the top-level agent and the subagents all share a single conversation history that grows as the request flows through the system.
BA manager and supervisor pattern with isolated context per subagent, where the top-level agent coordinates specialized subagents that each maintain their own conversation history and tool list.
CA retrieval-augmented pattern, where the top-level component retrieves relevant context from the subordinate components' indexed data stores before generating each response.
DA pipeline pattern, where each component processes the user request in sequence and passes the full conversation history along with the request to the next component in the pipeline.
Question #27Part 1Applications and Integration

You are designing a Claude application that preserves user sessions across multi-turn conversations. The product team has asked how the application will manage session lifecycle: when sessions should expire, how state is reset, and how it prevents stale context from being carried into new conversations. How would you design the session lifecycle?

ADefine explicit session expiration rules but rely on users to start new conversations when they want fresh context, with no automatic reset triggers in the application.
BDefine explicit session expiration rules, state reset triggers, and rules for starting fresh sessions so stale context does not leak into new conversations.
CDefine a single short session timeout that applies across all conversations and treat the timeout as the application’s complete session lifecycle mechanism.
DDefine state reset triggers tied to specific application events but apply them across all sessions globally, with no per-session expiration rules.

📢 Unlock Full Access to Success!

"The content displayed here is a promotional preview and contains only 50% of the actual exam database. To access the complete set of updated questions, please upgrade to the Full Version."

👉 Click the button and follow the instructions to secure your full access immediately!