GSTIN / Company Registration Number: 20AOBPD8112K1ZI
    All certifications
    CCDV-F

    Claude Developer – Foundations (CCDV-F) Practice Questions

    For engineers who build with the Claude API, Claude Code and MCP — from first integration to production agents.

    53 items on the real exam 120 min $125 Pass: 720/1000
    Take the timed CCDV-F mock exam

    Claude CCDV-F exam guide

    The Claude Developer – Foundations (CCDV-F) exam is 53 items, closed-book, proctored by Pearson VUE, with a 120-minute time limit. It costs $125 and uses a scaled score out of 1000, with 720 needed to pass. Engineers shipping Claude-powered applications. This page's question bank and flashcards are free and domain-weighted to match the breakdown below; the timed mock exam reproduces the full exam length and scoring.

    Exam domains & weighting

    DomainWeightYour progress
    Applications & Integration33.1%
    0/66
    Model Selection & Optimization16.8%
    0/34
    Agents & Workflows14.7%
    0/29
    Prompt & Context Engineering11%
    0/22
    Tools & MCPs10.6%
    0/21
    Security & Safety8.1%
    0/16
    Claude Code3.1%
    0/6
    Evaluation, Testing & Debugging2.6%
    0/6

    About these questions

    Every question below is written from scratch by GetDev, grounded in Anthropic's published exam domains and weightings plus general Claude, Claude Code and MCP product knowledge. None are reproduced from any other prep site. Each is tagged with its domain, subtopic and difficulty so you can target weak spots — use the filters in the Question bank tab.

    200 of 200 questions · 0 answered · 0 correct so far

    Q1
    Claude API fundamentals
    Foundational

    What is the core unit of interaction when calling the Claude Messages API?

    Q2
    Claude API fundamentals
    Foundational

    Why does the Messages API require the client to resend the entire conversation history on every call, rather than just the newest message?

    Q3
    Claude API fundamentals
    Applied

    An application sets `max_tokens` very low (e.g., 50) for a task that occasionally needs longer answers. What is the architectural consequence when the model's natural response would exceed that limit?

    Q4
    Claude API fundamentals
    Applied

    What does the `stop_reason` field in an API response communicate, and why should a production application check it rather than assuming every response completed naturally?

    Q5
    Claude API fundamentals
    Foundational

    What is the role of the `system` parameter versus a message with role `user` in the Messages API?

    Q6
    Claude API fundamentals
    Advanced

    An application needs the model to continue generating past where a previous response was cut off by `max_tokens`. What is the correct approach, given the API's stateless design?

    Q7
    Claude API fundamentals
    Foundational

    Why do official Claude SDKs (Python, TypeScript, etc.) exist rather than requiring every application to construct raw HTTP requests?

    Q8
    Claude API fundamentals
    Applied

    An application pins its integration to a specific, dated model version string rather than a generic 'latest' alias. What is the architectural tradeoff this represents?

    Q9
    Claude API fundamentals
    Advanced

    An application logs full request and response payloads for debugging, including conversation content that may contain customer PII. What architectural concern does this raise, independent of the Claude API itself?

    Q10
    Streaming responses
    Foundational

    What problem does streaming (`stream: true`) solve for a Claude-powered application compared to waiting for the complete non-streamed response?

    Q11
    Streaming responses
    Applied

    An application streams a response and needs to know when generation is fully complete versus just receiving another incremental chunk. What should it rely on?

    Q12
    Streaming responses
    Advanced

    An application needs the model to produce structured JSON output but also wants to stream it for responsiveness. What complication does streaming introduce for structured output specifically?

    Q13
    Streaming responses
    Foundational

    What happens to tool use in a streamed response — can a tool call be identified before the full response finishes?

    Q14
    Streaming responses
    Applied

    A streaming connection drops partway through a response due to a network interruption. What should a robust application do?

    Q15
    Streaming responses
    Advanced

    Why might an application choose non-streaming mode even for a reasonably long response, despite streaming's UX benefits?

    Q16
    Streaming responses
    Foundational

    In a chat UI backed by streaming, what is the practical benefit users actually perceive, even though the total time to full completion is roughly the same as non-streaming?

    Q17
    Streaming responses
    Applied

    An application streams model output directly into a webpage via `innerHTML` without any sanitization. What security risk does this introduce?

    Q18
    Authentication, API keys & key management
    Foundational

    Why should a Claude API key never be embedded directly in client-side (browser or mobile app) code?

    Q19
    Authentication, API keys & key management
    Applied

    What is the standard architectural pattern for letting a client-side application use Claude without exposing the API key?

    Q20
    Authentication, API keys & key management
    Foundational

    What is a key architectural reason to use separate API keys for development, staging, and production environments rather than one shared key everywhere?

    Q21
    Authentication, API keys & key management
    Advanced

    An API key is accidentally committed to a public GitHub repository and the commit is later removed. What is the architecturally correct response?

    Q22
    Authentication, API keys & key management
    Applied

    A team stores its API key directly in application source code as a string literal, rather than in an environment variable or a secrets manager. What is the architectural problem beyond the risk of accidental public exposure?

    Q23
    Authentication, API keys & key management
    Foundational

    What is the purpose of scoping or limiting what a given API key or workspace can do (e.g., spend limits, restricted model access) in a production deployment?

    Q24
    Authentication, API keys & key management
    Applied

    A backend service calls the Claude API on behalf of many different end users of an application. Should each end user have their own API key?

    Q25
    Rate limits, retries & error handling
    Foundational

    What is the purpose of API rate limits from the provider's perspective, and what should an application do when it receives a rate-limit error?

    Q26
    Rate limits, retries & error handling
    Applied

    An application receives a 5xx server error from the API. Is this generally safe to retry, and why?

    Q27
    Rate limits, retries & error handling
    Advanced

    An application implements retry logic but uses a fixed, short retry interval (e.g., always exactly 1 second) rather than exponential backoff. Under sustained rate limiting across many concurrent requests, what problem can this cause?

    Q28
    Rate limits, retries & error handling
    Foundational

    What does a 429 status code specifically indicate, as distinct from a 500-series error?

    Q29
    Rate limits, retries & error handling
    Applied

    An application sets an unbounded retry loop for rate-limit errors, planning to 'just keep trying until it works.' What operational risk does this create for an end user waiting on a response?

    Q30
    Rate limits, retries & error handling
    Advanced

    A production application wants to avoid ever hitting rate limits in the first place, rather than just handling them reactively with retries. What proactive architectural approach addresses this?

    Q31
    Rate limits, retries & error handling
    Foundational

    Why is it important for an application's error handling to distinguish between different 4xx error codes (e.g., 400 bad request vs. 401 unauthorized vs. 429 rate limited) rather than treating all 4xx errors identically?

    Q32
    Rate limits, retries & error handling
    Applied

    An application wraps every API call in a try/catch that silently swallows all errors and returns a generic fallback message, with no logging. What operational problem does this create?

    Q33
    Rate limits, retries & error handling
    Advanced

    A team wants to implement a circuit breaker pattern around their Claude API calls. What problem does a circuit breaker solve that simple per-request retry logic does not?

    Q34
    Multi-turn conversation & context management in apps
    Foundational

    In a chat application, what is responsible for maintaining the conversation history across multiple user messages, given the API's stateless design?

    Q35
    Multi-turn conversation & context management in apps
    Applied

    A chat application's conversation grows long enough that resending the full history on every call starts approaching the context window limit. What are reasonable application-level strategies to address this?

    Q36
    Multi-turn conversation & context management in apps
    Advanced

    An application summarizes older conversation turns to save context budget, replacing them with a condensed system-level summary. A user later references something specific they said many turns ago, before the summarization point. What architectural risk does this illustrate?

    Q37
    Multi-turn conversation & context management in apps
    Foundational

    What is a key reason a chat application might store conversation history with role-tagged messages (user/assistant) exactly as the API expects, rather than as a single flattened text blob?

    Q38
    Multi-turn conversation & context management in apps
    Applied

    A support chatbot needs to maintain context about which product a customer is asking about across many turns, even as the conversation drifts to cover several sub-questions. What is a robust application-level approach, beyond relying purely on the raw conversation history?

    Q39
    Multi-turn conversation & context management in apps
    Advanced

    An application allows a user to 'branch' a conversation — editing an earlier message and getting a new response from that point, while keeping the original branch accessible. What does this require architecturally, beyond a simple linear message list?

    Q40
    Multi-turn conversation & context management in apps
    Foundational

    Why might an application cap the number of historical turns resent on each call, even before hitting the hard context window limit?

    Q41
    Multi-turn conversation & context management in apps
    Applied

    A multi-turn conversation's history contains an early assistant turn where the model made a mistake that the user then corrected. The application keeps resending the original mistaken turn verbatim in all future calls. What problem can this create?

    Q42
    Vision / multimodal & document (PDF) input
    Foundational

    How is an image included in a request to the Messages API?

    Q43
    Vision / multimodal & document (PDF) input
    Applied

    An application needs to process a scanned, multi-page PDF document (e.g., extracting data from an invoice). What is an architectural consideration for how to handle the PDF?

    Q44
    Vision / multimodal & document (PDF) input
    Advanced

    An application sends a very high-resolution image to the API for a task that doesn't need fine visual detail (e.g., just classifying the image's general subject). What is the architectural tradeoff of sending the image at full resolution versus downscaling it first?

    Q45
    Vision / multimodal & document (PDF) input
    Foundational

    Why might an application need to handle multiple image formats (JPEG, PNG, WebP, etc.) rather than assuming a single format?

    Q46
    Vision / multimodal & document (PDF) input
    Applied

    An application extracts structured data from invoice images and needs the output tied back to which part of the image supported each extracted value. How does this connect to the citation/provenance principle discussed for context management and reliability?

    Q47
    Vision / multimodal & document (PDF) input
    Advanced

    An application sends a chart/graph image and asks the model to extract the exact underlying data values. What is a realistic limitation to design around?

    Q48
    Vision / multimodal & document (PDF) input
    Foundational

    Can a single message include multiple images alongside text, and what is a typical use case for doing so?

    Q49
    Vision / multimodal & document (PDF) input
    Applied

    An application sends user-uploaded images directly to the API without checking their dimensions or file size first, and some uploads are unusually large (very high resolution, many megabytes). What should the application account for, distinct from the earlier resolution-vs-accuracy tradeoff?

    Q50
    Prompt caching for applications
    Foundational

    What problem does prompt caching solve for an application that sends largely the same long context (e.g., a large system prompt or reference document) on every call?

    Q51
    Prompt caching for applications
    Applied

    An application's cached prefix includes content that changes on every single call (e.g., a timestamp embedded near the start of the prompt). What happens to caching effectiveness in this situation?

    Q52
    Prompt caching for applications
    Advanced

    A chatbot application with a large, static system prompt serves many different users concurrently. How does prompt caching's benefit scale with the number of users sharing that same static prompt?

    Q53
    Prompt caching for applications
    Foundational

    Why would an application deliberately structure its prompt with stable instructions first and highly variable, request-specific content last, independent of any other performance consideration?

    Q54
    Prompt caching for applications
    Applied

    A cached prompt prefix has a limited cache lifetime (it expires after a period of inactivity). What does this mean architecturally for an application with sporadic, infrequent traffic to a given cached prefix?

    Q55
    Prompt caching for applications
    Foundational

    What kind of content is a good candidate for prompt caching, and what kind is a poor candidate?

    Q56
    Prompt caching for applications
    Advanced

    An application caches a large reference document as part of its system prompt. The underlying document is later updated. What architectural responsibility does the application have regarding the cache?

    Q57
    Prompt caching for applications
    Applied

    A team is deciding whether prompt caching is worth implementing for their application. What question should drive that decision?

    Q58
    Prompt caching for applications
    Foundational

    How does prompt caching's cost model typically differ between writing to the cache versus reading from an existing cache hit?

    Q59
    Embeddings & RAG integration patterns
    Foundational

    What problem does a RAG (retrieval-augmented generation) architecture solve for an application that needs the model to answer questions about a large, private knowledge base?

    Q60
    Embeddings & RAG integration patterns
    Applied

    What is the role of embeddings in a typical RAG pipeline?

    Q61
    Embeddings & RAG integration patterns
    Advanced

    A RAG application chunks its knowledge base documents into fixed-size pieces (e.g., exactly 500 characters each) without regard for sentence or section boundaries. What problem can this introduce?

    Q62
    Embeddings & RAG integration patterns
    Foundational

    After retrieving relevant chunks via similarity search, how are they typically used in a RAG pipeline's final answer-generation step?

    Q63
    Embeddings & RAG integration patterns
    Applied

    A RAG application's similarity search returns chunks that are topically related to the query but don't actually contain the specific fact needed to answer it. What does this illustrate about retrieval quality?

    Q64
    Embeddings & RAG integration patterns
    Advanced

    How does RAG's citation/provenance story compare to the general citation-preservation principle discussed for context management and reliability?

    Q65
    Embeddings & RAG integration patterns
    Foundational

    Why might an application use a vector database rather than a general-purpose relational database to store and query embeddings at scale?

    Q66
    Embeddings & RAG integration patterns
    Applied

    A RAG application's knowledge base is updated frequently (new documents added daily). What architectural implication does this have for the embedding/indexing pipeline, compared to a knowledge base that's static?

    Q67
    Model family tradeoffs (capability vs cost vs speed)
    Foundational

    Why does Anthropic offer multiple model sizes/tiers rather than a single model for every use case?

    Q68
    Model family tradeoffs (capability vs cost vs speed)
    Applied

    An application uses the largest, most capable model for a simple, well-defined classification task (sorting support tickets into 5 categories) that a smaller model could likely handle just as well. What is the architectural cost of this choice?

    Q69
    Model family tradeoffs (capability vs cost vs speed)
    Advanced

    A team benchmarks a smaller model against a larger one on their specific task and finds the smaller model performs nearly as well, at a fraction of the cost. What should inform the final decision beyond the headline accuracy numbers?

    Q70
    Model family tradeoffs (capability vs cost vs speed)
    Foundational

    In a multi-step application workflow, why might different steps reasonably use different model tiers rather than one tier for the whole workflow?

    Q71
    Model family tradeoffs (capability vs cost vs speed)
    Applied

    A latency-sensitive, real-time application (e.g., a live voice assistant) needs to choose a model primarily optimized for response speed. What should the team be aware of when trading capability for speed in this way?

    Q72
    Model family tradeoffs (capability vs cost vs speed)
    Advanced

    A team initially picks the most capable model 'to be safe' during prototyping, planning to 'optimize down to a cheaper model later' before launch. What risk does this plan carry?

    Q73
    Model family tradeoffs (capability vs cost vs speed)
    Foundational

    What is a sound default strategy for choosing a model tier when starting a new feature, before extensive benchmarking data exists?

    Q74
    Model family tradeoffs (capability vs cost vs speed)
    Applied

    Two different model tiers are benchmarked on the same task and produce nearly identical accuracy, but one has notably lower per-request latency. All else being equal, why might the faster model still not be the automatic right choice?

    Q75
    Choosing model per task/step
    Foundational

    What is the first question to ask when selecting which model to use for a specific application feature?

    Q76
    Choosing model per task/step
    Applied

    A document-processing pipeline has a classification step (route to one of 4 document types) followed by an extraction step (pull out specific fields with careful reasoning about ambiguous cases). How should model selection likely differ between these two steps?

    Q77
    Choosing model per task/step
    Advanced

    A team is unsure whether a specific step in their pipeline truly needs the more capable (and costlier) model tier, or whether a lighter one would suffice. What is a rigorous way to answer this, rather than guessing?

    Q78
    Choosing model per task/step
    Foundational

    Why might a task involving creative or open-ended writing (e.g., drafting marketing copy) generally warrant a more capable model than a task involving strict data extraction from a well-structured source?

    Q79
    Choosing model per task/step
    Applied

    A step in a pipeline is currently using a capable model but the team observes its output quality barely changes when they experimentally swap in a lighter model. What does this observation suggest about their original model choice for that step?

    Q80
    Choosing model per task/step
    Advanced

    A step's task difficulty varies significantly by input — most inputs are simple, but a meaningful minority are genuinely hard. What architectural pattern addresses this better than picking one fixed model tier for the step?

    Q81
    Choosing model per task/step
    Foundational

    In an escalation-based model-routing pattern (light model first, escalate on failure/low-confidence), what determines whether the lighter model's attempt should be escalated?

    Q82
    Token usage optimization
    Foundational

    Why does reducing unnecessary tokens in a prompt matter beyond just the direct cost savings?

    Q83
    Token usage optimization
    Applied

    A system prompt includes several paragraphs of flowery, conversational framing before getting to the actual instructions. What token-optimization opportunity does this represent?

    Q84
    Token usage optimization
    Advanced

    A team wants to reduce token usage in their RAG application by retrieving fewer chunks per query. What tradeoff does this introduce?

    Q85
    Token usage optimization
    Foundational

    How does output token usage factor into total cost differently from input token usage, and why does this matter for optimization priorities?

    Q86
    Token usage optimization
    Applied

    An application asks the model to always restate the full original question before answering it, as part of every response. What token-optimization opportunity does this represent, and what should replace it if the restatement isn't actually needed downstream?

    Q87
    Token usage optimization
    Advanced

    A team wants to optimize token usage but is unsure which part of their pipeline (prompt, retrieved context, conversation history, or output) contributes most to total cost. What is the correct first step?

    Q88
    Latency optimization techniques
    Foundational

    Beyond choosing a faster model tier, what is another application-level lever for reducing perceived latency in a user-facing feature?

    Q89
    Latency optimization techniques
    Applied

    An application makes several sequential, independent API calls as part of handling one user request (e.g., three separate classification calls on unrelated pieces of the input). How can latency be improved here, assuming the calls don't depend on each other's output?

    Q90
    Latency optimization techniques
    Advanced

    An application wants to reduce latency for a specific, frequently-asked type of query by pre-computing and caching the full response ahead of time, rather than calling the model live each time. What is the key risk of this approach?

    Q91
    Latency optimization techniques
    Foundational

    How does prompt caching (discussed earlier for applications generally) specifically function as a latency optimization, not just a cost one?

    Q92
    Latency optimization techniques
    Applied

    A multi-step agentic workflow's total latency is dominated by waiting on several sequential tool calls, each of which depends on the previous step's output. What realistic latency optimization remains available here, given the calls cannot be parallelized due to their dependency chain?

    Q93
    Latency optimization techniques
    Advanced

    A team wants to optimize for latency but hasn't measured where time is actually being spent across their pipeline (model inference, network round-trips, application-side processing, etc.). What is the risk of optimizing without this breakdown?

    Q94
    Cost monitoring & budgeting
    Foundational

    Why should a production application implement cost monitoring (tracking actual API spend over time) rather than only estimating cost once during initial design?

    Q95
    Cost monitoring & budgeting
    Applied

    An application's cost monitoring shows a sudden, unexplained spike in API spend. What should this trigger, architecturally?

    Q96
    Cost monitoring & budgeting
    Advanced

    A team sets a hard spend cap on their API usage to avoid runaway cost, such that requests are rejected once the cap is hit within a billing period. What user-experience consideration does this introduce, paralleling a lesson from tool-boundary enforcement?

    Q97
    Cost monitoring & budgeting
    Foundational

    What is the benefit of attributing API cost to specific features or user segments, rather than only tracking total aggregate spend?

    Q98
    Cost monitoring & budgeting
    Applied

    An agentic feature in an application has no bound on how many tool calls or iterations a single task can consume. What cost-monitoring and budgeting risk does this create, connecting to the retry-cap and iteration-budget principles discussed for agentic reliability?

    Q99
    Cost monitoring & budgeting
    Advanced

    A team wants to forecast future API cost as their application scales, rather than only reacting to current spend. What makes this forecasting non-trivial, beyond simple linear extrapolation of current spend?

    Q100
    Cost monitoring & budgeting
    Foundational

    Why is it useful to track cost per unit of business value (e.g., cost per resolved support ticket) rather than only tracking raw API spend in isolation?

    Q101
    Agent loop basics for developers
    Foundational

    At the implementation level, what is the basic loop structure a developer builds when giving Claude access to tools?

    Q102
    Agent loop basics for developers
    Applied

    A developer builds an agent loop with no maximum iteration count, assuming the model will naturally stop calling tools once the task is done. What production risk does this create?

    Q103
    Agent loop basics for developers
    Advanced

    In a hand-rolled agent loop, after executing a tool and getting a result, what message role and structure should the tool's result be sent back as?

    Q104
    Agent loop basics for developers
    Foundational

    Why does the application, not the model itself, bear responsibility for actually executing a requested tool call (e.g., running the database query, calling the external API)?

    Q105
    Agent loop basics for developers
    Applied

    A developer's agent loop executes a requested tool call synchronously and blocks on it before continuing. For a tool that takes a long time to complete (e.g., a slow external API), what architectural option exists to avoid blocking the entire application during that wait?

    Q106
    Agent loop basics for developers
    Advanced

    A developer wants to let a user observe an agent loop's progress in real time (which tool is being called, intermediate results) rather than seeing only the final answer. What does this require architecturally, beyond the basic loop?

    Q107
    Tool use implementation patterns
    Foundational

    When defining a tool for the API, what three things does the tool definition need to specify at minimum?

    Q108
    Tool use implementation patterns
    Applied

    A tool's input schema marks a field as optional when the underlying function actually requires it to be present to work correctly. What problem does this schema/implementation mismatch create?

    Q109
    Tool use implementation patterns
    Advanced

    A developer is deciding whether to expose a complex multi-step business process (e.g., 'process a return') as one single tool, or as several smaller tools the model calls in sequence (e.g., 'look up order,' 'validate return eligibility,' 'issue refund'). What factors should drive this decision?

    Q110
    Tool use implementation patterns
    Foundational

    What is the purpose of the `tool_choice` parameter (or equivalent) in the API, which can force, allow, or prevent tool use for a given call?

    Q111
    Tool use implementation patterns
    Applied

    A developer forces tool use (via `tool_choice`) to guarantee the model's response is a specific tool call matching a defined schema, effectively using tool calling as a structured-output mechanism. What should still be validated after this?

    Q112
    Tool use implementation patterns
    Advanced

    A developer defines a tool whose input schema includes a deeply nested object with several levels of sub-objects and arrays. What practical implementation challenge does this raise, beyond what a flatter schema would?

    Q113
    Workflow orchestration (sequential/parallel in code)
    Foundational

    At the code level, what determines whether two steps in a workflow should be implemented as sequential (one `await`ed after another) or parallel (both started concurrently)?

    Q114
    Workflow orchestration (sequential/parallel in code)
    Applied

    A developer runs three independent classification calls in parallel using `Promise.all` (or equivalent). One of the three calls fails while the other two succeed. What should the application's error handling account for?

    Q115
    Workflow orchestration (sequential/parallel in code)
    Advanced

    A workflow has five steps where steps 2 and 3 are independent of each other but both depend on step 1, and step 4 depends on both 2 and 3, with step 5 depending on step 4. How should this be orchestrated for the best latency, and what does this illustrate about dependency structure?

    Q116
    Workflow orchestration (sequential/parallel in code)
    Foundational

    Why might a developer choose to implement workflow orchestration using an existing workflow/orchestration framework or library rather than hand-rolling the control flow from scratch?

    Q117
    Workflow orchestration (sequential/parallel in code)
    Applied

    A workflow step occasionally needs to branch — taking a different subsequent path depending on the result of a model call (e.g., if sentiment is negative, escalate; otherwise, proceed normally). How is this typically implemented, compared to a workflow with no branching?

    Q118
    Workflow orchestration (sequential/parallel in code)
    Advanced

    A long-running, multi-step workflow needs to survive an application restart partway through (e.g., a server redeploy) without losing its progress. What architectural requirement does this impose, beyond the basic sequential/parallel orchestration logic?

    Q119
    Error handling in agent workflows
    Foundational

    In an agent loop, a tool call fails with an error. What should the application do with that error, architecturally?

    Q120
    Error handling in agent workflows
    Applied

    An agent loop's tool call fails, the error is fed back to the model, and the model tries again with slightly different arguments — but it keeps failing and retrying in a way that never converges on success. What should bound this behavior?

    Q121
    Error handling in agent workflows
    Advanced

    A workflow step depends on an external API that is temporarily down. The agent loop keeps retrying that single step while the rest of the otherwise-independent workflow (steps that don't depend on this external API) sits idle waiting. How could this be architected better?

    Q122
    Error handling in agent workflows
    Foundational

    Why is it important for error handling logic in an agent workflow to distinguish between an error in the model's own response (e.g., an API error from Anthropic) versus an error from a tool execution the application performed?

    Q123
    Error handling in agent workflows
    Applied

    An agent workflow fails partway through a multi-step task that had already made some real-world changes (e.g., it successfully updated one record before failing on a second, related update). What does this scenario highlight the need for?

    Q124
    Error handling in agent workflows
    Advanced

    A developer wants their agent workflow's error handling to be testable, so failure scenarios can be verified without waiting for a real external failure to occur naturally. What implementation approach supports this?

    Q125
    Testing agent behavior
    Foundational

    Why is testing an agentic feature (one involving model calls and tool use) generally harder than testing traditional deterministic code?

    Q126
    Testing agent behavior
    Applied

    A team writes a test that asserts a chatbot's response to a given input must exactly match one specific string. What problem does this testing approach run into for an agentic/generative feature?

    Q127
    Testing agent behavior
    Advanced

    What is a more appropriate testing strategy than exact-string matching for verifying an agentic feature behaves correctly across a range of inputs?

    Q128
    Testing agent behavior
    Foundational

    Why is it valuable to maintain a fixed, curated set of test inputs (a regression test suite) for an agentic feature, re-run whenever the prompt or model changes?

    Q129
    Testing agent behavior
    Applied

    A team's regression test suite for an agentic feature only includes 'easy,' typical inputs and no genuinely hard or adversarial edge cases. What gap does this leave in their testing coverage?

    Q130
    Prompt structuring for applications
    Foundational

    Why do many production prompts use explicit structural markers (e.g., XML-style tags) to separate distinct pieces of content, such as instructions, reference material, and the actual input to process?

    Q131
    Prompt structuring for applications
    Applied

    An application's prompt interleaves instructions and user-provided input without any clear separation (e.g., 'Summarize this: ' immediately followed by raw, unescaped user text that could itself contain phrases that look like instructions). What risk does this create?

    Q132
    Prompt structuring for applications
    Advanced

    A team maintains prompts as raw strings concatenated directly in application code, making small wording tweaks directly in the codebase whenever they want to adjust behavior. What architectural downside does this create as the application and team grow?

    Q133
    Prompt structuring for applications
    Foundational

    Why might an application use prompt templates (with variable placeholders filled in at request time) rather than constructing each prompt as an entirely bespoke string per request?

    Q134
    Prompt structuring for applications
    Applied

    A prompt template interpolates raw user input directly into a template string without any consideration for how special characters or template-syntax-like content in that input might be handled. What is the architectural risk?

    Q135
    Prompt structuring for applications
    Advanced

    A team wants to make a significant change to a core, widely-used prompt template (used across many different application features). What process consideration does this warrant, beyond simply editing the template and deploying?

    Q136
    System prompts in production apps
    Foundational

    In a production application serving many different end users, what is a typical architectural pattern for constructing the system prompt per request?

    Q137
    System prompts in production apps
    Applied

    An application's system prompt grants the model a broad persona ('You are a helpful assistant that can discuss anything') for a product that's actually meant to be scoped narrowly (e.g., only answering questions about the company's own product). What problem can this mismatch create?

    Q138
    System prompts in production apps
    Advanced

    A team wants their system prompt to enforce that the assistant never discusses a specific competitor by name, under any circumstances. Given the deterministic-vs-model-judgment principle, how reliable should they expect a system-prompt-only instruction to be for this requirement?

    Q139
    System prompts in production apps
    Foundational

    Why might a system prompt include explicit instructions about what the assistant should do when it doesn't know an answer or lacks sufficient information, rather than leaving this unaddressed?

    Q140
    System prompts in production apps
    Applied

    An application injects dynamic, per-user data (e.g., the user's name, account tier, recent activity) into the system prompt on every call. What consideration from prompt caching does this interact with?

    Q141
    Context window management in long-running apps
    Foundational

    What is the first thing an application should do when designing for a conversation that could, in principle, grow indefinitely long?

    Q142
    Context window management in long-running apps
    Applied

    An application simply truncates (drops) the oldest messages once a conversation exceeds a certain length, with no summarization. What is the tradeoff of this approach compared to summarization?

    Q143
    Context window management in long-running apps
    Advanced

    An application summarizes older conversation turns using a separate Claude API call (asking the model to condense prior history), adding this as an extra step in the application's flow. What operational cost does this summarization strategy itself introduce?

    Q144
    Context window management in long-running apps
    Foundational

    Why might an application set a hard maximum on conversation length (e.g., after N turns, prompting the user to start a new conversation) rather than relying solely on truncation or summarization to handle unbounded growth?

    Q145
    Context window management in long-running apps
    Applied

    An application's context management strategy summarizes aggressively, keeping conversations very short in terms of token count. A user later complains the assistant seems to 'forget' things they mentioned earlier in the same session. How does this connect to a tradeoff discussed for context compaction generally?

    Q146
    Context window management in long-running apps
    Advanced

    A team wants to preserve specific, important facts (e.g., a customer's stated preferences) across a summarization event, without relying on the summary to capture them reliably by chance. What architectural pattern addresses this?

    Q147
    Few-shot examples in production prompts
    Foundational

    In a production application, where do few-shot examples typically live, and why does this matter for maintainability?

    Q148
    Few-shot examples in production prompts
    Applied

    An application's few-shot examples were written when the product launched and have never been revisited, even as the product's real usage patterns have evolved significantly. What risk does this create?

    Q149
    Few-shot examples in production prompts
    Advanced

    A team considers dynamically selecting which few-shot examples to include per request (e.g., picking examples most similar to the current input from a larger example pool) rather than using one fixed set of examples for every call. What tradeoff does this introduce relative to a fixed example set?

    Q150
    Few-shot examples in production prompts
    Foundational

    Why might a team include a deliberately negative example (showing an input and an explicitly incorrect or undesired output, labeled as such) alongside positive few-shot examples?

    Q151
    Few-shot examples in production prompts
    Applied

    A team is deciding how many few-shot examples to include for a moderately well-specified task. What should guide this number, beyond 'more examples are always better'?

    Q152
    Implementing tool definitions (developer-level, schema/JSON)
    Foundational

    What schema format does the Claude API use for defining a tool's expected input parameters?

    Q153
    Implementing tool definitions (developer-level, schema/JSON)
    Applied

    A tool's schema defines a parameter as an enum with a fixed set of allowed string values (e.g., `status: ['open', 'closed', 'pending']`). What practical benefit does this provide over defining the parameter as an unconstrained free-text string?

    Q154
    Implementing tool definitions (developer-level, schema/JSON)
    Advanced

    A developer is writing a tool's JSON Schema and must decide whether a given parameter should be marked `required`. What should drive this decision?

    Q155
    Implementing tool definitions (developer-level, schema/JSON)
    Foundational

    Beyond type information, what other kind of constraint can a JSON Schema parameter definition include that helps guide the model toward valid input (e.g., for a numeric 'quantity' field that must be positive)?

    Q156
    Implementing tool definitions (developer-level, schema/JSON)
    Applied

    A developer writes a tool schema with a parameter description that just restates the parameter's name (e.g., a field named `start_date` with description 'the start date'). What improvement would make this more useful to the model?

    Q157
    Implementing tool definitions (developer-level, schema/JSON)
    Advanced

    A tool accepts a parameter that is an array of objects, each with several required fields. What practical implementation consideration does this nested-array-of-objects shape raise for the developer, beyond a flat set of top-level parameters?

    Q158
    Using MCP servers as a client/developer
    Foundational

    From an application developer's perspective, what does connecting to an existing MCP server provide, compared to writing custom integration code for that same external system from scratch?

    Q159
    Using MCP servers as a client/developer
    Applied

    A developer's application connects to multiple different MCP servers simultaneously (e.g., one for a CRM, one for an internal database, one for a ticketing system). How does the application's experience of tool availability change as a result?

    Q160
    Using MCP servers as a client/developer
    Advanced

    A developer connects their application to a third-party MCP server they don't control or operate themselves. What operational risk does this external dependency introduce, beyond the risk of using their own first-party tools?

    Q161
    Using MCP servers as a client/developer
    Foundational

    Before connecting an application to a third-party MCP server, what should a developer evaluate, similar to vetting any other external dependency or library?

    Q162
    Using MCP servers as a client/developer
    Applied

    An application connects to an MCP server whose available tools can change over time (the server adds, removes, or modifies tools independently of the connecting application's own release cycle). What does this imply for the application's robustness?

    Q163
    Using MCP servers as a client/developer
    Advanced

    A developer is deciding whether to connect their application directly to several third-party MCP servers, or to build a single internal MCP server that itself aggregates and re-exposes a curated subset of those external capabilities. What architectural benefit might the aggregation approach provide?

    Q164
    Building a basic MCP server
    Foundational

    At a basic level, what two things must a developer implement to expose a capability as an MCP server?

    Q165
    Building a basic MCP server
    Applied

    A developer builds an MCP server wrapping their company's internal API. The underlying internal API already has its own authentication requirements. How should the MCP server handle this?

    Q166
    Building a basic MCP server
    Advanced

    A developer building an MCP server is deciding how granular to make the exposed tools — one broad tool mirroring the internal API's single flexible endpoint, or several narrower, purpose-specific tools built on top of it. How does the earlier granularity discussion (single vs. several smaller tools) apply here?

    Q167
    Building a basic MCP server
    Foundational

    Why should error handling inside an MCP server's tool handler logic follow the structured-error-response principle discussed earlier, rather than letting an unhandled exception propagate or returning a bare failure signal?

    Q168
    Building a basic MCP server
    Applied

    A developer wants to test their newly built MCP server's tools before connecting it to a production application. What is a sound approach?

    Q169
    Debugging tool-call failures
    Foundational

    A developer is debugging a case where the model called a tool with unexpected or incorrect arguments. What is the first thing to inspect?

    Q170
    Debugging tool-call failures
    Applied

    A tool call intermittently fails — it works correctly most of the time but occasionally produces malformed arguments for what appears to be the same type of request. What debugging approach fits this pattern better than assuming a single deterministic bug?

    Q171
    Debugging tool-call failures
    Advanced

    A developer suspects a tool-call failure is caused by the model running low on relevant context by the time it reaches that point in a long conversation (e.g., earlier context got compacted or pushed out). What would help confirm or rule out this hypothesis?

    Q172
    Debugging tool-call failures
    Foundational

    Why is comprehensive logging of tool calls (what was called, with what arguments, what result came back) valuable for debugging, beyond just helping with the specific failure currently being investigated?

    Q173
    Input validation / prompt injection defenses
    Foundational

    What is prompt injection, in the context of an application that includes untrusted content (user input, retrieved documents, web content) in its prompts?

    Q174
    Input validation / prompt injection defenses
    Applied

    An application summarizes web pages fetched based on a URL the user provides. What is the realistic prompt-injection risk here, and what does it imply for how much trust the application should place in the fetched content?

    Q175
    Input validation / prompt injection defenses
    Advanced

    A developer considers prompt injection 'solved' once they've clearly delimited user/retrieved content from instructions using structural markers (e.g., XML tags). Is this a complete mitigation?

    Q176
    Input validation / prompt injection defenses
    Foundational

    Why does an agentic application with tool access raise the stakes of prompt injection compared to a simple text-generation-only application?

    Q177
    Input validation / prompt injection defenses
    Applied

    A developer wants to add a mitigation specifically for the scenario where an agent might be induced (via injection) to call a destructive tool unexpectedly. Beyond prompt-level delimiting, what architectural mitigation directly addresses this, drawing on a principle from tool design?

    Q178
    Secrets & credential handling in agent code
    Foundational

    An agentic application's tool handler code needs credentials to call an internal API. Where should those credentials come from, consistent with the API-key-management principles discussed for application backends generally?

    Q179
    Secrets & credential handling in agent code
    Applied

    An agent's conversation logs (kept for debugging) occasionally capture tool call arguments that include sensitive values (e.g., an internal auth token passed as a parameter for a specific call). What risk does this create, and what should the application do about it?

    Q180
    Secrets & credential handling in agent code
    Advanced

    An agent is given a tool that requires a highly privileged credential (e.g., full administrative database access) because 'it might need that level of access for some edge case someday.' How does this connect to the least-privilege and tool-availability-defines-scope principles discussed earlier?

    Q181
    Secrets & credential handling in agent code
    Foundational

    Why is credential rotation (periodically replacing API keys/secrets with new ones) a recommended practice for agentic application infrastructure, same as for any backend system?

    Q182
    Output handling safety (sanitization before executing/displaying)
    Foundational

    An application takes code generated by the model and executes it directly with no review or sandboxing. What is the architectural risk?

    Q183
    Output handling safety (sanitization before executing/displaying)
    Applied

    An application displays model-generated Markdown directly to users by rendering it as HTML, without restricting which Markdown/HTML features are allowed. What specific risk does this raise, beyond the general innerHTML/XSS concern discussed for streamed output?

    Q184
    Output handling safety (sanitization before executing/displaying)
    Advanced

    An application constructs a SQL query by directly interpolating a value the model generated (e.g., as part of a text-to-SQL feature) into a query string, rather than using parameterized queries. What risk does this introduce?

    Q185
    Output handling safety (sanitization before executing/displaying)
    Foundational

    What is the general principle connecting all of these output-handling risks (XSS from rendered output, unsafe code execution, SQL injection from interpolated model output)?

    Q186
    Least-privilege for API keys/tool scopes (dev-level)
    Foundational

    At implementation time, what is a concrete way a developer applies least-privilege to a specific agent's tool configuration?

    Q187
    Least-privilege for API keys/tool scopes (dev-level)
    Applied

    A single backend service handles requests for multiple different agent features (one customer-support agent, one internal-reporting agent) using one shared API key and one shared, combined toolset passed to every call regardless of which feature is making the request. What is the architectural improvement here?

    Q188
    Least-privilege for API keys/tool scopes (dev-level)
    Advanced

    A developer scopes an agent's toolset tightly for its primary task, but one of the included tools (a general-purpose 'run_database_query' tool) is far broader than the agent's actual need (it only ever needs to read from one specific table). What does true least-privilege require here, beyond just limiting which tools are included?

    Q189
    Using Claude Code CLI & SDK as a developer
    Foundational

    From a developer's perspective, what distinguishes using Claude Code interactively in a terminal from building a custom application on the raw Claude API?

    Q190
    Using Claude Code CLI & SDK as a developer
    Applied

    A developer wants to build a custom application that embeds agentic coding capability (similar to what Claude Code does) rather than using Claude Code's own CLI/IDE interface directly. What does the Claude Agent SDK provide for this purpose?

    Q191
    Using Claude Code CLI & SDK as a developer
    Advanced

    A developer wants their custom agentic application to support something like Claude Code's CLAUDE.md pattern — persistent, project-scoped configuration automatically loaded into context. How does this relate to the system-prompt-construction principles discussed for applications generally?

    Q192
    Automating workflows with Claude Code (CI/headless)
    Foundational

    What does running Claude Code in a 'headless' mode (e.g., as part of a CI/CD pipeline) mean, compared to its typical interactive terminal use?

    Q193
    Automating workflows with Claude Code (CI/headless)
    Applied

    A team wants to use Claude Code in a CI pipeline to automatically review pull requests, but is deciding how much autonomy to grant it (e.g., can it merge PRs itself, or only leave review comments). What principle from earlier in this domain should drive this decision?

    Q194
    Automating workflows with Claude Code (CI/headless)
    Advanced

    A headless Claude Code automation in a CI pipeline occasionally produces an unexpected or incorrect result with no human watching in real time to catch it immediately. What mitigation approach connects most directly to the monitoring and evaluation principles discussed for agentic reliability generally?

    Q195
    Writing evals for Claude-powered features
    Foundational

    What is the basic structure of an eval (evaluation) for a Claude-powered feature?

    Q196
    Writing evals for Claude-powered features
    Applied

    A team builds an eval set but populates it entirely with inputs the developers personally thought of while writing the code, with no real production data or deliberately adversarial cases included. What limitation does this introduce, connecting to a principle from testing agent behavior?

    Q197
    Writing evals for Claude-powered features
    Advanced

    A team wants to use Claude itself to grade the outputs of another Claude call as part of an automated eval (an 'LLM-as-judge' pattern), rather than writing exact-match or rule-based checks. What should they be aware of with this approach?

    Q198
    Debugging unexpected model output
    Foundational

    A developer sees unexpected output from a model call and wants to debug it. What is the most direct, first piece of information to inspect?

    Q199
    Debugging unexpected model output
    Applied

    A developer reconstructs the exact request sent for a problematic call and finds nothing obviously wrong with the prompt itself. What should they check next, connecting to the non-determinism property discussed for testing agent behavior?

    Q200
    Debugging unexpected model output
    Advanced

    A developer identifies that a specific, reproducible prompt reliably produces an undesired output. Having confirmed the issue is real and not just one-off variability, what should guide the fix, connecting to prompt engineering principles discussed elsewhere?

    0/70 known

    Questions about the CCDV-F exam