Free Claude Certified Developer - Foundations (CCDV-F) Practice Questions

Sample CCDV-F Practice Questions

Browse all 20 free Claude Certified Developer - Foundations practice questions below.

1. A Python FastAPI backend forwards chat requests to Claude's Messages API. A developer is writing the minimal request body for a single completion. Which set of top-level fields is required on every Messages API request?

   • Only `messages`, because the model and token limit are inferred from the API key's default configuration on the server
   • `model`, `max_tokens`, and `messages`
   • `model`, `system`, `temperature`, and a `session_id` that the API uses to store conversation state on the server between calls
   • `prompt` and `stop_sequences`, following the older text-completions request shape rather than the Messages format

2. A developer new to LLMs asks what a 'context window' means when working with Claude. Which description is accurate?

   • It is the maximum number of separate conversations Claude can keep open at once for a single API key across the whole account
   • It is the wall-clock time limit after which an idle streaming connection is closed by the server during a long response
   • It is the number of tools Claude can call within a single agentic loop before the server forces the turn to pause
   • It is the maximum number of tokens (input plus output) the model can process in a single request

3. A startup is deciding between a fixed workflow and an autonomous agent for a feature that extracts three known fields from uploaded invoices using a single, well-specified prompt. Which approach fits best, and why?

   • Use a workflow with a single Messages API call, because the task is fully specified and does not require the model to plan its own multi-step trajectory across tools
   • Use an autonomous agent with a tool-use loop, because any task that involves documents benefits from letting the model decide its own steps
   • Use a multi-agent manager and subagent system so each field is extracted by its own dedicated subagent for maximum accuracy
   • Use an agent with persistent memory so it can recall previously processed invoices across every future request

4. A Node/TypeScript chatbot fetches and summarizes web pages that end users submit by URL. One submitted page contains hidden text instructing the model to ignore its instructions and email the conversation history to an attacker. Which TWO practices most effectively reduce this prompt-injection risk? (Select TWO)

   • Treat the fetched page content as untrusted data and keep it structurally separated from the system instructions
   • Increase the model's temperature so its responses become harder for an attacker to predict in advance
   • Append a sentence to the system prompt politely asking web authors not to embed malicious instructions in their pages
   • Apply least-privilege guardrails, for example via hooks, so injected text cannot trigger the email-sending tool
   • Switch to the largest available model, because larger models never follow injected instructions

5. A developer is building a customer-support assistant and wants Claude to always adopt a consistent persona and follow the same rules regardless of what the user types. Where should these durable, role-defining instructions go?

   • Appended to the end of every single user message so they are always the most recent text the model reads before answering
   • Encoded into the API key's metadata so they are automatically attached to every request the key makes
   • In the top-level `system` prompt, which is designed for durable role and rule instructions
   • Split across the `stop_sequences` and `metadata` fields so the instructions do not consume any context tokens

6. A developer builds a streaming customer-support chat UI on the Messages API. After enabling extended thinking on the request, code that reads response.content[0].text starts throwing a type error on some responses. What is the cause?

   • Enabling thinking makes the Messages API return a plain string instead of an array of content blocks, so indexing by [0] no longer works.
   • With thinking enabled a thinking block can precede the text block, so content[0] is not always the text; iterate over content and check each block's type.
   • Thinking suppresses all text output unless max_tokens is raised above the internal thinking budget, which leaves content empty and makes the index invalid.
   • The SDK requires a separate call to a thinking endpoint to retrieve the final text once thinking has been enabled on the request.

7. A mobile app backend classifies incoming push-notification text as urgent or normal. The volume is very high, the task is simple, and latency per request must stay low. Which model tier best fits?

   • Opus, because the most capable model produces the most reliable classifications even for trivial two-way labeling tasks.
   • Sonnet, because a mid-tier model is always the safest default for any production classification workload regardless of complexity.
   • Haiku, because it is the fastest and most cost-effective tier and the task is simple and latency-sensitive at high volume.
   • Whichever model has the largest context window, since bigger context always yields better classification accuracy on short inputs.

8. A team is deciding whether to build a fixed workflow or an autonomous agent for a document-processing feature. Which TWO conditions most favor building an agent rather than a hard-coded workflow? (Select TWO)

   • The task is multi-step and hard to fully specify in advance, so the model needs to decide its own trajectory.
   • The processing steps are identical for every input and can be written out completely ahead of time.
   • The outcome justifies higher latency and cost, and errors can be detected and recovered from through tests or review.
   • You want the lowest possible per-request cost and latency above all other considerations.
   • The output must conform to a fixed JSON schema on every request without exception.

9. In a CI code-review integration, a tool named post_review_comment is available to Claude, but the model rarely calls it even when it finds real bugs. What is the most effective fix?

   • Rewrite the tool description to be prescriptive about when to call it, for example "Call this when you identify a bug in the diff," rather than only describing what it does.
   • Raise the temperature on the request so the model behaves less predictably and calls the tool more often by chance.
   • Force tool_choice to require a tool on every request so the review comment tool is always invoked.
   • Add several more tools to the request so the model has more options, and increase the temperature at the same time so it explores the expanded tool set more freely on each pass.

10. A mobile backend wraps the Messages API behind its own REST endpoint. The upstream call returns HTTP 429 with a retry-after header. What should the backend do?

    • Return HTTP 400 to the mobile client immediately, since a 429 means the request itself was malformed and should not be retried.
    • Treat the 429 as an authentication failure, rotate the API key, and resend the request with the new key.
    • Immediately retry the request in a tight loop with no delay, opening extra parallel connections so at least one attempt gets through the rate limit faster.
    • Respect the retry-after delay and back off before retrying, since 429 is a retryable rate-limit response and the SDKs already retry it with exponential backoff.

11. A data-enrichment worker must tag 50,000 support tickets with product categories before a weekly report. The job runs overnight, results are only needed the next morning, and minimizing spend is the top priority. Which approach fits best?

    • Fan out 50,000 concurrent synchronous Messages API calls so the job finishes in minutes, accepting the higher realtime pricing and rate-limit pressure
    • Submit the tickets through the Message Batches API, which handles large asynchronous jobs within a 24-hour window at reduced cost
    • Send the tickets one at a time synchronously and retry any that hit rate limits
    • Reduce max_tokens on each synchronous request to lower the per-call price

12. A team needs to convert currency amounts in incoming invoices using a fixed three-step sequence: extract the amount, call an FX rate API, then write the converted value. The steps never change. Should they build an autonomous agent or a workflow?

    • An autonomous agent, because any task that calls an external API requires agentic tool use to be reliable
    • An autonomous agent with adaptive thinking, so it can decide the order of the three steps on each run
    • A workflow with code-orchestrated steps, because the sequence is fixed and predictable
    • A manager agent supervising three subagents, one per step, to maximize parallelism

13. A mobile app must classify each incoming chat message as positive, neutral, or negative in real time, at very high volume, where per-request cost and latency matter most and the task itself is simple. Which model tier is the best default?

    • Claude Haiku, the fastest and most cost-effective tier for simple, high-volume tasks
    • Claude Opus, to guarantee the highest possible classification accuracy on every message
    • Claude Sonnet with maximum effort, to balance quality and cost on every single request
    • Alternate between Opus and Sonnet per request to spread out rate-limit usage

14. A research assistant agent fetches and summarizes web pages that end users submit. One page contains hidden text telling the model to call the agent's send_email tool and forward internal notes. Which TWO practices best reduce this prompt-injection risk? (Select TWO)

    • Treat fetched page content as untrusted data and keep it clearly separated from trusted system instructions
    • Increase the model's effort level so it reasons more carefully about every instruction it reads
    • Apply least-privilege guardrails, for example hooks, so injected text cannot trigger sensitive tools like send_email
    • Add a system-prompt sentence politely asking submitted pages not to include malicious instructions
    • Switch to a larger model, which follows instructions more reliably and is therefore safer against injection

15. In a coding agent harness, Claude rarely calls the available search_codebase tool even when it would help. The tool works correctly when invoked. What is the most effective first fix?

    • Force tool_choice to always require the search_codebase tool on every single request the harness makes
    • Raise the model temperature so it explores tool calls more often
    • Rename the tool to something shorter so it is easier for the model to select
    • Write a clearer tool description that states specifically when to call it, not just what it does

16. A developer building an internal inventory MCP server finds that Claude often calls the get_stock tool with missing or wrong arguments. Which TWO practices most improve how reliably Claude calls the tool? (Select TWO)

    • Write a clear, detailed description that states what the tool does, when to use it, and what each parameter means
    • Keep the description to one or two words so it uses fewer tokens
    • Define a precise input schema with typed parameters and mark required fields as required
    • Rely on the function name alone and leave the parameters undocumented
    • Return raw stack traces to Claude whenever a lookup fails so it can debug the server internally

17. A developer is making a first call to the Claude Messages API and wants standing instructions (persona and output format) applied to every turn, separate from the user's actual question. Where should each go?

    • Put both the standing instructions and the question into a single user message
    • Pass the standing instructions in the top-level system parameter and the user's question as a user message
    • Add the instructions as an assistant message so Claude treats them as its own earlier output instead of as authoritative, always-applied guidance
    • Add a message with the role "system" inside the messages array next to the user turns

18. A support platform must classify a very high volume of incoming tickets into a fixed set of simple categories. Latency and cost matter more than nuanced reasoning. Which model choice fits best?

    • Opus, the most capable tier, so classification accuracy is maximized regardless of latency or cost
    • Sonnet with extended thinking enabled on every ticket to be safe
    • Haiku, the fastest and lowest-cost tier, which fits simple high-volume classification
    • Rotate randomly across tiers per request to spread the load

19. A fintech web app currently ships with the ANTHROPIC_API_KEY hardcoded in the browser JavaScript bundle. What is the correct fix?

    • Keep the key in the frontend but obfuscate and minify the bundle so it is hard to read
    • Commit the key to a private repository and inline it into the bundle at build time
    • Rotate the key weekly while keeping it embedded in the client bundle
    • Store the key server-side and have the browser call your backend, which in turn calls Claude

20. A chat UI should display Claude's answer token by token as it is generated instead of waiting for the whole response. Which API capability provides this?

    • Enable streaming, which returns incremental server-sent events as tokens are produced
    • Poll the Messages API on a short interval until the complete response is ready
    • Reduce max_tokens so the whole response comes back sooner
    • Submit the request through the Message Batches API to lower latency