CCDV-F practice questions, free.

A response comes back with stop_reason set to max_tokens. What happened?

• The output reached the max_tokens limit and was cut off before the model finished
• The input exceeded the context window and the request was rejected with a 400
• The model reached the natural end of its turn, so the text is complete as returned
• The model emitted a tool_use block and is waiting for a tool_result from your code

A response has stop_reason tool_use. What must your code do next?

• Execute the requested tool, append a tool_result block with the matching id, and call the model again
• Retry the same request with tool_choice set to none so the model answers in plain text
• Return the text blocks to the user, since the API already executed the tool on the server side before responding
• Wait for the model's next message, which will carry the tool_result once execution finishes

Users should see the answer appear as it is generated. What do you use?

• Set stream to true and render content_block_delta events as they arrive
• Poll the messages endpoint with the message id until a status field reports completion
• Submit the request through the Message Batches API and read results as they land
• Lower max_tokens so each response returns quickly enough to feel incremental

You have 20,000 documents to classify overnight, with no latency requirement, and cost matters. Best choice?

• Submit them through the Message Batches API and collect results when the batch completes
• Send 20,000 synchronous requests through a worker pool sized to your rate limit
• Concatenate all the documents into one request with a large max_tokens and split the output back apart by document
• Stream each request so results can be written to disk as the tokens arrive

Every request includes the same 30,000-token reference manual followed by a short question. How do you cut cost?

• Upload the manual through the Files API so its tokens are billed once instead of per request
• Send the question first and the manual second so the model reads the task before the context
• Put a cache_control breakpoint on the manual block so the prefix is reused across requests
• Lower temperature and max_tokens so each request generates fewer billable output tokens

Your integration starts receiving HTTP 429 responses. What is the right client behavior?

• Rotate to a second API key from the same organization so requests keep flowing
• Treat 429 as a transient server fault and fail the request back to the user
• Retry immediately in a tight loop, since the limit clears as soon as the window rolls over
• Back off exponentially with jitter and honor the retry-after header when it is present

A pipeline extracts three fields from short emails, millions of times a month. Which model tier makes sense?

• The most capable tier, since extraction errors at this scale compound quickly
• A mid tier with extended thinking enabled to raise accuracy on ambiguous fields
• The tier with the largest context window, so that long quoted email threads are not truncated before extraction
• The smallest tier that passes your eval, since cost and latency dominate at this volume

You need the same input to produce the same extraction every time. Which setting helps most?

• Add a longer system prompt that describes each field in detail
• Set temperature near 1 so the model commits firmly to a single answer
• Set temperature near 0 so sampling favors the most likely tokens
• Enable prompt caching so the cached prefix yields the same output

Which loop correctly implements a tool-using agent?

• Call the model once with tool_choice any and return the first tool_use arguments
• Call the model; on tool_use run the tool, append the result, call again; stop on end_turn or a turn cap
• Call the model repeatedly until its text no longer mentions any tool by name
• Run every declared tool up front with default arguments, then pass all of the results to the model in a single call

What does the Claude Agent SDK handle for you that a hand-rolled loop does not?

• Automatic retries, rate-limit backoff, and typed request and response objects
• Fine-tuning the model on your repository before the first run
• The agent loop, tool execution, permission checks, hooks, and subagents
• Server-side tool execution so your code does not have to handle tool_use blocks

A multi-turn assistant's history grows until requests fail. What is the sane fix?

• Summarize older turns and keep the most recent turns verbatim
• Raise max_tokens so the request budget covers the longer history
• Add a cache_control breakpoint so older turns stop counting toward the window
• Send only the latest user message and rely on the system prompt to carry state

A tool parameter may only be one of three values. How do you express that?

• Describe the three allowed values in the tool description text and validate the string in your handler
• Set tool_choice to the tool's name so the model cannot pass other values
• Split the capability into three separate tools, one per allowed value
• Use an enum in the parameter's JSON schema and list the parameter under required

Your agent reads web pages. One page contains text telling the assistant to email the user's files to an address. What protects you?

• Rely on the model's safety training to recognize and ignore the injected instruction
• Add a line to the user prompt telling the model to disregard instructions found in pages
• Treat retrieved content as data, keep instructions in the system prompt, and gate outbound actions
• Fetch the pages server-side and pass them as plain user text so the model treats them as the user's own words

An agent has a shell tool in production. What is the least-privilege setup?

• Run the shell inside a container as root so the agent cannot reach the host
• Restrict the tool to a single working directory in a sandbox but allow any command to run inside that directory
• Allow every command but log each one so a reviewer can audit the session later
• Allow a reviewed list of read-only commands and require approval for anything that writes

You changed a prompt and want to know whether quality regressed before shipping. What do you run?

• Compare token counts between the old and new prompts to check for drift
• Spot-check a handful of representative examples by hand and ship if the outputs still look right
• Run a load test to confirm latency did not change with the new prompt
• Run a golden test set with automated grading and compare scores with the old prompt

Which fields are required in a Messages API request?

• model, messages, and system
• model, messages, and temperature
• model, messages, and max_tokens
• model, max_tokens, and stream

Where does the system prompt go in a Messages API request?

• As a text block at the start of the first user message
• As the first entry in messages with role set to system
• In the top-level system parameter of the request
• In the metadata object alongside the user_id

A response's content array contains a text block followed by a tool_use block. What does that mean?

• The model wrote some text, then requested a tool call; you run it and return a tool_result
• The response was truncated by max_tokens while writing the tool arguments
• Two parallel responses were merged; keep the tool_use block and drop the text
• The model finished its turn with end_turn; the tool_use block is a suggestion your code may ignore

Your app sends an image for analysis. How is it included?

• As a file uploaded through the Files API and referenced from the tools array by its file id
• As a data URL pasted into the text of the user message
• As an image content block, with a base64 or URL source, inside a user message
• As an image block inside the system parameter next to the instructions

What does stop_reason end_turn tell you?

• The model finished its turn naturally and is not waiting on anything
• The model stopped at a stop sequence you supplied in the request
• The output was cut off because the response reached max_tokens
• The model paused a long-running server tool turn and you should call again

A streaming response is interrupted midway. What should a robust client do?

• Render the partial text as the final answer, since deltas are already committed
• Detect the missing message_stop event, then retry or mark the partial output as incomplete
• Send a follow-up request with stop_reason set to resume so the model continues
• Fall back to non-streaming requests for the rest of the session so the failure does not recur

You need consistent structured data from many documents. Which approach is most robust?

• Define a tool with a JSON schema for the fields, force it with tool_choice, and validate the arguments
• Extract the values from free text with regular expressions tuned on sample documents
• Ask for a markdown table in the prompt, set temperature to 0, and split each returned row on the pipe character
• Set temperature to 0 and ask for JSON, trusting the output to be well formed

Which header carries your credential when calling the API directly?

• Authorization with a Bearer token
• anthropic-version with the key appended
• x-api-key with the key as its value
• x-anthropic-token with the key as its value

A request returns HTTP 400 with an invalid_request_error. Most likely cause?

• The request exceeded the rate limit for your organization's tier
• The model is overloaded and the request should be retried later
• The API key is valid but the organization lacks permission for the requested model
• A malformed body, such as a missing required field or an unsupported parameter

What is the Files API useful for?

• Caching a document so later requests skip input token billing for it
• Storing conversation history server-side so you send only new turns
• Uploading a document once and referencing it by file id across many requests
• Attaching a document to a Message Batch so every request inside that batch can read it

A batch job finished but some requests show errors. What should your code do?

• Retry the batch at a smaller size so fewer requests time out
• Read each request's result, retry the failed ones, and treat the batch as non-atomic
• Cancel the batch and resubmit every request, since partially failed batches are not billed at all
• Treat the whole batch as failed and raise an error for the caller to handle

You want to count tokens before sending a large prompt to avoid exceeding limits. Which capability?

• The token counting endpoint, which returns input tokens for a prompt
• The count_tokens flag on the messages request
• An estimate from character count divided by four
• The usage field on the streaming message_start event, which reports input tokens early

Which SDK pattern avoids re-implementing the tool loop by hand?

• Streaming with a callback that executes tools inline
• A tool runner or agent helper provided by the SDK
• Wrapping the messages call in a retry decorator
• Setting tool_choice to auto so the API runs the tools itself

A multi-turn app appends every response to the history. After 50 turns the requests fail. What is the fix?

• Raise max_tokens so the model has room to answer the longer thread
• Trim or summarize older turns to stay inside the context window
• Add a cache_control breakpoint so cached turns are excluded from the limit
• Switch to a model with extended thinking to handle the longer input

Which is the best practice for choosing a model tier for a new feature?

• Use the largest tier for anything customer-facing and the smallest tier for internal tooling and scripts
• Pick the tier with the largest context window so prompts will not need trimming
• Prototype on a capable tier, then test whether a smaller tier passes your eval at lower cost
• Start on the smallest tier and move up only when users report errors

Output tokens dominate latency for a summarization endpoint. Which lever helps most?

• Enable prompt caching on the source document so the whole response is served faster
• Move the request to the Message Batches API for higher throughput
• Constrain the output length and format so the model writes fewer tokens
• Add extended thinking so the model plans before writing the summary

What does max_tokens control?

• The size of the prompt prefix that is eligible for caching
• The maximum number of output tokens the model may generate
• The number of tokens kept when the context window overflows
• The total tokens allowed across input and output for the request

A classification endpoint with a fixed label set should use which sampling setting?

• Low temperature so the same input maps to the same label
• A high top_p so rare labels are not excluded
• High temperature so the model explores less obvious labels
• Default temperature with top_k raised to widen the candidate set

When does extended thinking justify its cost?

• On every request, since thinking is cached and free after the first call
• On short factual lookups where the answer must be verified twice
• On streaming requests, where thinking fills time while text arrives
• On hard multi-step problems where accuracy matters more than latency

Your bill is dominated by a stable 20k-token system prompt sent on every call. First optimization?

• Add a cache_control breakpoint to the system prompt so its tokens are read from cache
• Move the prompt into the first user message so it is billed as one block
• Switch to a smaller model tier, since input tokens cost less there
• Send the requests through the Batch API to get the discounted rate

Which workload is a good fit for the Batch API?

• An IDE assistant that answers as the developer types
• A voice agent that needs turn-by-turn responses
• Nightly enrichment of a million records with no latency requirement
• A live customer chat reply that must appear on screen within a couple of seconds

What is a reasonable way to compare two models for your task?

• Run the same eval set through both and compare accuracy, cost, and latency
• Compare context window sizes and choose the larger one
• Ask each model to rate its own fitness for the task
• Pick the newer model, since each release is documented as improving on the last

In a hand-rolled agent loop, what must happen before calling the model again after a tool call?

• Remove the tool_use block from history so the model does not call it again
• Change tool_choice to none so the model must answer in text
• Append a tool_result block whose tool_use_id matches the tool_use block
• Reset the conversation and resend the system prompt with the tool output

Which pattern fits 'translate, then have a second call grade the translation, then revise until it passes'?

• Routing by input type
• Orchestrator-workers
• Parallel sectioning
• Evaluator-optimizer loop

What should limit an agent loop besides end_turn?

• A maximum number of iterations plus a time or cost budget
• The context window, which ends the loop once it fills up
• A stop sequence that fires when the model writes the word done
• A max_tokens value low enough to stop long-running turns

The Claude Agent SDK's hooks are useful for:

• Switching the model mid-run when a task turns out to need more capability than expected
• Rewriting the system prompt between turns based on the user's tone
• Injecting API credentials into the environment before each tool runs
• Running deterministic checks around tool calls, such as blocking a dangerous command

A workflow has a step that sometimes needs human input. How should the code model it?

• A default value so the step completes and the human reviews afterwards
• A pause state that persists progress and resumes when the input arrives
• A blocking loop that polls for the input every few seconds until it appears
• A retry policy that restarts the workflow from the top once input exists

Which is true about subagents in the SDK?

• They must use the same system prompt and model as the parent
• They run with their own context and return a result to the parent
• They share the parent's full conversation so nothing needs restating
• They run tools only through the parent, which executes on their behalf

Why give each workflow step one responsibility?

• Each step becomes testable on its own and failures are easier to localize
• It lets every step share one system prompt across the whole workflow, which keeps behavior consistent
• Smaller steps use fewer tokens per run, which lowers cost
• The API rejects steps that combine more than one tool

Where should a long reference document sit relative to the question in a prompt?

• Before the question, clearly delimited
• In the system prompt instead of a user turn
• Split evenly across several user turns
• After the question, so the task is read first

Which technique reduces the chance that instructions inside a document are followed?

• Shorten the document so injected text has fewer tokens to work with
• Wrap documents in tags, label them as data, and keep instructions outside them
• Set temperature to 0 so the model sticks to its original instructions
• Put the document in the system prompt so it carries top-level authority

What is the benefit of putting the system prompt in the system parameter rather than the first user message?

• It removes the instructions from the request's input token count
• It lets you change instructions mid-conversation without a new request
• Standing instructions stay stable and separate, and the prefix caches well
• The model gives the system parameter absolute priority over any later user turn or tool result

How can you make an extraction prompt more reliable without changing the model?

• Raise temperature so the model handles unusual inputs flexibly
• Remove the schema so the model is not constrained by rigid fields
• Give the model a persona of an experienced data analyst
• Add examples of input and expected output, including an edge case

A prompt has grown to 300 lines with contradictory rules. What should you do?

• Add a final rule stating that whenever two rules conflict, the later one in the prompt wins
• Split it across two models, one per half of the rules
• Move it to the system parameter so the model weights it more
• Refactor it: remove conflicts, group rules, and test against a golden set

Which is a good reason to summarize conversation history rather than truncate it?

• Summaries are cached, so they do not count as input tokens
• Truncated histories are rejected by the API with a 400 invalid_request_error
• Summaries let you skip the system prompt on later turns
• Summarization keeps decisions and state that truncation would drop

What does a tool_result with is_error set to true tell the model?

• The API will retry the tool automatically on the next turn
• The tool has been removed from the tools list for the session
• The conversation must end and the client should surface the error text to the user
• The call failed and the content explains why, so the model can adapt

What is tool_choice set to 'any' for?

• Require the model to call some tool this turn, without naming which
• Let the model decide whether to call a tool or answer in text
• Force the model to call one specific named tool
• Allow the model to call several tools in parallel within one assistant turn

Your app connects to an MCP server over streamable HTTP. What must the client handle?

• Session handling and authentication for the remote server
• Selecting which model the server should use for its tools
• Spawning the server as a local subprocess over stdio
• Compiling the server from source before each connection

Which is a good tool description?

• 'Retrieves order information. Call this whenever the user asks anything about orders, shipping, refunds, or accounts.'
• 'Look up an order by order_id. Use when the user cites an order number. Returns status, items, shipping; errors on unknown id.'
• 'Order lookup tool. Accepts an id string and returns the order record from the orders service as JSON.'
• 'Fetch order details. See the internal API docs for parameter names, return fields, and error codes.'

How should a tool report that a required parameter was missing?

• Raise an exception so the agent loop terminates cleanly
• Return an empty success result so the model moves on
• Return an error result naming the missing parameter
• Fill in a sensible default and note it in the result

An API key was committed to a public repository. First action?

• Rotate the key, remove it from the code, then audit recent usage
• Rename the environment variable so scanners no longer match it
• Rewrite git history to drop the commit and force-push, then keep using the same key
• Restrict the key to your server's IP range in the console

Which practice limits damage from prompt injection in a document-processing app?

• Restrict which actions document content can trigger and confirm side effects
• Add more rules to the system prompt about ignoring document content
• Run each document through a second model call that strips embedded instructions first
• Disable logging so injected content cannot leak into your logs

User data appears in your logs in plain text. What should change?

• Log the full request and response bodies as well so audits have complete context
• Redact or minimize personal data in logs and set a retention policy
• Encrypt the log files at rest and leave their contents unchanged
• Move the logs to a private bucket that only engineers can read

Which file gives Claude Code standing instructions for a repository?

• CLAUDE.md at the repository root or in .claude
• .claude/settings.json under an instructions key
• A .clauderc file in the user's home directory
• README.md, which Claude Code reads on startup

How do you run Claude Code for a single non-interactive prompt in a script?

• Start the TUI and pipe the prompt in as keystrokes
• Run claude --batch with a file of prompts
• Call the Messages API directly with the same system prompt
• Run claude -p with the prompt as an argument