Free CCDV-F Exam Braindumps
Claude Certified Developer - Foundations Questions 26–30 (page: 7)

Updated On: 18-Sep-2026

Your Claude application's API keys are stored in a secrets manager. The team is debating whether the same key should be used in development, staging, and production environments.
How would you handle the keys across environments?

  1. Use distinct keys for each environment so a compromise in one environment does not affect the others during normal operation across the application's lifecycle.
  2. Rotate the same key across environments at random intervals on the grounds that random rotation provides isolation between environments without requiring distinct keys.
  3. Use 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.
  4. Use 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.

Answer(s): A

Explanation:

Option A provides proper environment isolation and credential blast-radius control. Development, staging, and production represent different trust boundaries and should not share the same API credential. If a development machine, CI job, or staging service is compromised, a distinct credential prevents the attacker from automatically gaining the same access to production.
Anthropic's official workspace documentation explicitly recommends using separate workspaces for development, staging, and production. Workspaces can have their own API keys, members, resource limits, and usage tracking, and keys can be scoped to a specific workspace. Anthropic's authentication guidance also instructs developers to store API keys in a secrets manager, rotate them periodically, revoke suspected compromised keys, and use workspaces to scope credentials by project or environment.
B confuses rotation with isolation: rotating a credential that remains shared across all environments does not create independent security boundaries. C deliberately increases blast radius. D merely substitutes one globally shared key for another and therefore has the same architectural flaw.
The supplied exam source marks A as correct. Relevant topics: Confia Management, secrets management, API-key scoping, environment isolation, credential rotation, workspaces, least privilege, and production security.



A teammate has asked you to explain why the team's Claude application is billed for output tokens at a different rate than input tokens. They had assumed the rate was the same for both.
How would you explain the difference?

  1. Output tokens are typically billed at the same rate as input tokens, and the apparent rate difference is a billing error to report to Anthropic.
  2. Output tokens are typically billed at a lower rate than input tokens, because output tokens are cheaper to produce than input tokens are to process.
  3. Output tokens are not billed at all, because cost is determined entirely by the input tokens sent to the model on each request.
  4. Output tokens are typically billed at a higher rate than input tokens, and cost models for the application should reflect both rates separately.

Answer(s): D

Explanation:

The supplied Claude Certified Developer Foundations question identifies D as the correct answer. Anthropic prices input and output tokens separately, so application cost models must independently account for the number of tokens supplied to Claude and the number generated in response.
Anthropic's official pricing documentation confirms that output-token pricing is normally higher than base input-token pricing. For example, current Claude models maintain distinct columns for base input tokens and output tokens; the exact dollar amounts depend on the selected model. This distinction matters because an application with relatively small prompts but very large generated responses can incur substantial output-token expenditure even when input volume is modest.
Therefore, cost forecasting should use approximately: input tokens input rate + output tokens output rate, with additional adjustments where prompt caching, batch processing, server tools, or other pricing modifiers apply. Option A incorrectly assumes equivalent rates, B reverses the normal relationship, and C incorrectly excludes generated tokens from billing.
Relevant Claude Developer topics: Claude API Mechanics, token accounting, model pricing, input/output token usage, cost modeling, prompt caching, and production API economics.



A Claude application is occasionally refusing to answer questions that should be in scope, including questions the application has answered correctly in the past. You want to investigate.
What is the first step of your investigation?

  1. Test whether removing or adjusting those instructions resolves the behavior.
  2. Examine traces of the refused requests to identify what triggers the refusal, whether input patterns, system prompt content, or other context.
  3. Assess whether the refusals cluster around specific input patterns, question types, or time periods by analyzing the distribution of refused requests in the logs.
  4. Identify which questions have been refused and compare them against previously answered questions to determine what changed between the successful and refused interactions.

Answer(s): B

Explanation:

The supplied exam source marks B as correct. The first debugging action should be evidence collection rather than immediately modifying prompts or configuration. A trace exposes the complete conditions under which the refusal occurred: user input, system instructions, accumulated conversation state, tool results, parameters, and resulting model output.
This is important because a refusal can originate from several interacting causes. A particular input pattern may trigger it; system instructions may unintentionally conflict with the requested task; prior conversational context may alter Claude's interpretation; or contextual information may make an otherwise acceptable request appear out of scope. Without examining the failing execution path, changing instructions is speculative.
Option A jumps directly to remediation before identifying the cause. C provides useful aggregate analysis but is more appropriate after individual failing executions have been inspected. D is also valuable for comparative debugging, but determining what changed requires the detailed execution data that traces provide.
The correct troubleshooting sequence is therefore: capture or inspect representative failed traces, determine the trigger, compare against successful interactions, formulate a hypothesis, make a targeted change, and re-evaluate.
Relevant Claude Developer topics: Systems Life Cycle, observability, production debugging, tracing, failure analysis, refusals, regression investigation, and evaluation-driven remediation.



You are starting a new Claude application and have a small set of well-labeled examples that demonstrate the desired output format. You want to use these examples to guide Claude's behavior.
How would you guide the application's behavior?

  1. Use multi-shot prompting by including the labeled examples in the prompt so Claude can match the desired output format on each request.
  2. Use zero-shot prompting and rely on the model's general capability to produce the desired output format consistently across all incoming requests.
  3. Embed the examples in a database and retrieve them at runtime as reference material for the team.
  4. Train a custom model on the labeled examples before deployment so that the application does not need to include the examples in any prompt during operation.

Answer(s): A

Explanation:

The supplied examination set identifies A as correct. A small collection of high-quality labeled examples is ideally suited to few-shot or multishot prompting. The examples demonstrate concretely what acceptable input/output behavior looks like, allowing Claude to infer formatting, structure, tone, and task-specific conventions without requiring model retraining.
Anthropic's official prompting guidance states that examples are among the most reliable ways to steer Claude's output format, tone, and structure. It recommends using relevant, diverse examples and clearly separating them from the surrounding instructions. Anthropic currently recommends approximately three to five examples where practical and suggests XML structures such as <examples> and <example> to make prompt organization explicit.
B discards useful supervision by relying exclusively on zero-shot behavior. C is unnecessary for a small fixed set and does not ensure those examples are actually visible to Claude unless additional retrieval logic is created. D introduces unnecessary training complexity for a behavior that prompting already addresses efficiently.
Therefore, A provides the lowest-complexity, highest-leverage solution.
Relevant Claude Developer topics: Agent Construction, multishot prompting, few-shot learning, labeled examples, prompt design, output formatting, behavioral steering, and prompt evaluation.



A teammate has asked you to explain when a Skill would be the right choice over an MCP server. The teammate is unsure how the two differ in practice when both can be reused across teams.
How would you explain the distinction?

  1. A 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.
  2. A 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.
  3. A 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.
  4. A Skill bundles prompts, scripts, and data into a package the model loads as a unit while an MCP server exposes resources, tools, and prompts through a standard client interface.

Answer(s): D

Explanation:

The supplied Claude Developer question explicitly identifies D. The two mechanisms solve different extension problems. A Skill is a reusable package of domain expertise and workflow guidance. Anthropic describes Agent Skills as modular, filesystem-based capabilities containing instructions, metadata, and optional supporting resources such as scripts and templates, which Claude can load when relevant.
MCP, by contrast, defines a standardized mechanism for exposing external capabilities and context. Anthropic's MCP integration supports MCP tools and, through client-side helpers, MCP prompts and resources. This makes MCP appropriate when Claude must communicate with an external server or reusable service interface rather than simply load packaged expertise.
Thus, Skills are appropriate for packaging repeatable instructions, procedures, scripts, templates, or domain knowledge. MCP servers are appropriate for exposing callable operations, external data resources, and shared service capabilities using the Model Context Protocol.
A incorrectly treats them as interchangeable. B incorrectly describes the difference as merely generational. C invents a universal efficiency advantage that is not the architectural distinction.
Relevant Claude Developer topics: Agent Construction, Agent Skills, MCP, reusable capabilities, resources, prompts, tools, extension architecture, and cross-team component reuse.



Viewing page 7 of 22
Viewing questions 31 - 35 out of 103 questions


Post your Comments and Discuss Anthropic CCDV-F exam prep with other Community members:

AI Tutor AI Tutor 👋 I’m here to help!