Claude Certified Developer (CCDV-F) — Questions 226–257

resources/read is the MCP method that retrieves the content of a specific resource identified by its URI. In this scenario, the developer wants to fetch only the requested HR policy document on demand, which is exactly what resources/read provides. The server returns the resource contents, and Claude can then use that information to answer the user's question without preloading all documents.

Claude Code can read multiple files and follow references across the repository, so asking it to trace a request path produces a synthesized explanation that would otherwise require hours of manual navigation. This directly serves the goal of understanding flow before editing, and the summary gives the developer a map they can verify against the source.

The max_tokens parameter is a required top-level parameter in the Messages API that specifies the maximum number of tokens to generate in the response. It acts as a hard limit; the model will stop once it reaches this number or when it finishes naturally. Setting it appropriately prevents excessively long responses and controls cost. This is the correct parameter for the scenario.

Claude 3 Haiku has a lower cost per token than Claude 3 Opus. Switching to Haiku for a task like generating product descriptions, which does not require the advanced reasoning of Opus, reduces the cost per API call. This is a direct cost-saving measure as long as the smaller model meets quality requirements.

The user defines the vision and validates the output. The AI serves as an extension of the developer's capabilities, performing the routine coding tasks. This partnership ensures that the agent's output is aligned with high-level goals while the user provides the necessary human oversight and quality assurance.

Defining a persona and style guide provides the model with a set of rules for its responses. This ensures that the model understands not just what to say, but how to say it, creating a uniform experience that is predictable and aligned with the intended brand identity.

Custom slash commands are defined as markdown files under `.claude/commands` and are invoked by typing a short slash command. The file can contain the full multi-step instruction, so the developer triggers the whole workflow with one command. This is the documented way to package repeatable prompts for reuse across sessions in a project.

Output token cost is directly proportional to the number of tokens the model generates in its response. In this scenario, the response is 500 tokens, so the output cost is based on those 500 tokens. The input tokens (system prompt and user message) affect input cost separately, but the question asks specifically about output token cost.

Requiring a supporting quote before the answer forces the model to locate evidence in the manual, and the explicit 'not covered' escape hatch gives it a legitimate response when evidence is absent. This directly reduces answers drawn from general knowledge about competing products.

The Agent SDK thrives on message history; by appending the results of the specialized agent's work to the shared message thread, the Router can see exactly what was accomplished. This follows the standard Anthropic message protocol where tool outputs and assistant responses form a coherent narrative for the model.

Even though Claude follows the JSON schema, it can still generate malicious or unexpected inputs if prompted by a user. The MCP server must treat all model-generated arguments as untrusted input, performing rigorous validation and sanitization to prevent attacks like SQL injection, path traversal, or remote code execution.

The 'computer' tool is specifically designed for GUI interaction. It provides the model with the ability to see the screen via screenshots and interact with it by sending clicks, key presses, and cursor movements, enabling the agent to navigate traditional desktop software as a human user would.

When a content block is marked with 'cache_control', the system stores the processed tokens. If a follow-up request contains the exact same text, the model reuses the cached state. These 'cache hits' are billed at a fraction of the cost of standard input tokens, leading to substantial savings for repetitive tasks.

The legal template is large and mostly identical across requests, making it an ideal candidate for Prompt Caching. Cache reads are billed at a reduced rate, and the template content remains unchanged, so output fidelity is preserved. This directly targets the largest repeated input component and is a standard cost optimization for template-heavy pipelines.

Claude Haiku is positioned as the fastest and most cost-effective model in the Claude family, making it ideal for high-volume, low-complexity tasks like FAQ responses. It provides sufficient quality for straightforward question answering while keeping per-token costs low. This aligns directly with the startup's goal of minimizing cost during prototyping.

Since billing is calculated per token, reducing the amount of context directly lowers the cost of the request. In a production environment with millions of calls, stripping away irrelevant data ensures that the budget is spent only on the information necessary for the model to produce a correct and helpful response for the user.

Scoping the task and limiting tools reduces ambiguity and prevents the subagent from wandering into unrelated actions. A focused description plus a minimal toolset keeps the subagent's context small and its behavior predictable, which is the core reason to delegate to a subagent rather than expanding the main agent's responsibilities.

Setting 'is_error: true' is the standard way to notify Claude that the tool execution failed. By providing a descriptive error message in the content, you give the model enough context to handle the failure gracefully, such as by apologizing to the user or suggesting an alternative course of action.

Sanitizing and validating user input reduces the likelihood of known injection patterns reaching the model. While not foolproof, it adds a defensive layer that can catch common attacks. This practice is part of a defense-in-depth strategy and helps prevent the model from being manipulated by malicious content in uploaded documents.

The bot's output should never be the sole authority for a consequential action. By treating repository content as untrusted input and gating merges on human review or a deterministic policy engine, an injected instruction can at most produce a misleading comment, not an unauthorized approval. This removes the attacker's ability to convert text into a privileged action.

overloaded_error signals transient capacity pressure on the server and is designed to be retried. Exponential backoff with jitter spreads retries so a client does not hammer the endpoint, improving the chance of success. This is the recommended handling for that error class.

Input tokens represent the data sent to the API, including system instructions, context, and user queries. Anthropic charges based on the quantity of these tokens, and large context windows or extensive document embeddings directly increase this portion of the bill. Monitoring input volume is essential for maintaining a predictable budget during scaling phases.

Prompt injection occurs when a user provides input designed to override the system's intended behavior. The specific phrase 'Ignore all previous instructions' is a hallmark of this attack vector. Identifying this allows the application to implement filtering logic that detects these phrases and blocks the request before it reaches the model.

The error message contains the context needed for the model to re-evaluate its strategy. By surfacing the specific technical error, you enable the agent to self-correct, adjust its arguments, or switch to a different tool to achieve the desired goal.

This is a core capability. The agent reads files to understand the project structure and logic, providing summaries that help the developer navigate the codebase faster. This read-only access is entirely safe and provides the necessary context for the agent to be helpful and accurate.

Prompt Caching allows the developer to mark static content with a 'cache_control' block. When subsequent requests share the same cached prefix, Claude can skip the computation for those tokens. This reduces the time-to-first-token and provides a substantial discount on the input token costs for the cached portion.

This tiered approach, known as model routing or chaining, optimizes for both cost and intelligence. Haiku handles the high-volume, low-complexity extraction task cheaply and quickly, while the more expensive Sonnet is reserved for the difficult reasoning phase. This balance ensures the agent remains reliable while keeping the overall cost per execution much lower than using Sonnet alone.

The 'id' field is critical for maintaining the integrity of the conversation. It allows the SDK and the model to associate a 'tool_result' with its corresponding 'tool_use' request. This is especially important in complex interactions where multiple tools might be called or where the conversation spans many turns.

When stop_reason is tool_use, the model has paused and is waiting for tool output. The correct loop is to execute the requested tool and return the result as a tool_result content block in a user turn, preserving the assistant's tool_use turn first. This lets the model continue reasoning with the result.

In the Anthropic streaming API, each content block (text or tool_use) is bracketed by start and stop events. By listening for the 'content_block_stop' event for a 'tool_use' block, the developer ensures they have the full, valid JSON for the tool call and can safely execute it locally.

The developer writes the loop logic that inspects the model's response for tool-use blocks, executes the corresponding functions, and feeds the results back into the history. This is the standard orchestration pattern for agentic workflows using the Anthropic SDK.

Prompt Caching stores the static codebase prefix server-side for a short TTL, so repeated requests within that window are billed at a discounted cache-read rate instead of full input token price. Because the codebase rarely changes, the cache hit rate is high and latency improves. This directly reduces per-request input cost while preserving full context fidelity.