Claude Certified Developer Associate

Navigate directories and run Python scripts from a command-line terminal.

Use Python variables, primitive data types, and expressions to transform values.

Write conditional statements using if, elif, and else to execute Python code conditionally.

Write for and while loops to iterate over sequences and repeat tasks in Python.

Define and call Python functions with parameters and return values.

Create, index, and modify Python lists to manage ordered collections.

Store, update, and retrieve key-value pairs in Python dictionaries to represent structured records.

Handle predictable failures with Python exceptions and clear error messages.

Create a virtual environment and install a Python package with pip.

Parse JSON text into Python objects and serialize Python objects as JSON.

Identify the method, URL, headers, and body in an HTTP request.

Interpret common HTTP success and error status codes in an API response.

Load a local-development API key from an environment variable without placing it in source code.

Translate API documentation into the parameters required for a Python request.

Send a REST API request from Python and extract data from its JSON response.

Distinguish a model's context window from its generated-output limit.

Identify tasks that suit an LLM and tasks that require deterministic software or human judgment.

Compare Claude models using capability, latency, context, and price requirements.

Calculate the approximate token cost of a single Claude API interaction.

Recognize how rate limits and latency constraints affect an application's design.

Choose a model-routing rule that balances task difficulty, latency, reliability, and cost.

Configure the Anthropic Python SDK with an API key and instantiate a client.

Send a basic request through the Messages API and read the returned text content.

Use system instructions and user messages for their distinct conversational roles.

Inspect Claude message content blocks, stop reasons, and token-usage metadata.

Represent prior turns correctly in a multi-turn Messages API request.

Process a streaming response incrementally in a Python application.

Classify common API failures as authentication, validation, rate-limit, or server errors.

Implement bounded retries with backoff for retryable Claude API failures.

Separate deterministic application logic from tasks delegated to Claude.

Sketch the data flow and trust boundaries of a Claude-powered application.

Separate application code, prompts, model settings, and environment-specific configuration.

Version a prompt and its associated model configuration so a prior behavior can be reproduced.

Map development, testing, deployment, monitoring, and improvement activities onto an AI system lifecycle.

Design a production secret-handling plan that uses managed secret storage and rotation without exposing secrets in source code.

Instrument a Claude application to record request identifiers, latency, token usage, and errors without logging sensitive content.

Write a prompt with an explicit task, relevant context, constraints, and success criteria.

Use structural delimiters to separate instructions, source material, and user-supplied content.

Create few-shot examples that demonstrate the required behavior without conflicting signals.

Request JSON output that conforms to a specified field structure and data types.

Validate a model's structured output and handle malformed or incomplete results safely.

Select context that is relevant and sufficient for a specific model task.

Order instructions, evidence, examples, and the current request to reduce ambiguity.

Implement a sliding-window truncation strategy that removes older conversation turns while keeping total tokens within limits.

Summarize prior conversation turns into a condensed block that preserves essential context across long interactions.

Divide a document into retrieval chunks using its structure and expected query type.

Explain how embeddings and similarity search support semantic retrieval.

Choose retrieved passages using relevance thresholds and a top-k limit.

Construct a grounded prompt that distinguishes retrieved evidence from instructions and requests citations.

Define a Claude tool with a clear description and valid JSON input schema.

Write tool descriptions that help Claude choose between similar available tools.

Implement a Python function that validates and executes a tool request.

Detect a tool-use content block and map its name and input to the correct function.

Return a tool result with the matching tool-use identifier in the next user message.

Implement a bounded model-tool loop that stops on a final response or explicit limit.

Represent tool failures so Claude can recover without concealing the error.

Identify when parallel tool calls are safe and when calls must remain sequential.

Distinguish an autonomous agent loop from a predetermined workflow.

Implement prompt chaining with an explicit validation gate between steps.

Route a request to a specialized prompt or handler using defined classification criteria.

Use parallelization to combine independent model-assisted subtasks.

Apply an orchestrator-worker pattern to a task that must be decomposed dynamically.

Apply an evaluator-optimizer loop with a measurable stopping criterion.

Complete a scaffolded Claude Agent SDK application that can invoke an allowed tool.

Select a single-call, workflow, or agent architecture from stated requirements.

Explain the responsibilities of MCP hosts, clients, and servers in an integration.

Distinguish MCP tools, resources, and prompts by how a client uses them.

Complete a scaffolded minimal Python MCP server that exposes one validated tool.

Connect an MCP client to a server and verify a tool call end to end.

Use Claude Code to inspect a repository and complete a narrowly scoped coding task.

Write project instructions that give Claude Code stable repository context and constraints.

Package bounded instructions and resources as a reusable Claude Code skill.

Configure a Claude Code hook to run a deterministic check at a selected lifecycle event.

Threat-model a Claude application for prompt injection, data leakage, excessive agency, and unsafe tool use.

Enforce least-privilege permissions and execution boundaries for agent tool interactions.

Validate untrusted model, user, and tool data at each application trust boundary.

Place input, output, and action guardrails at appropriate points in an application flow.

Configure agent limits and termination conditions to prevent unbounded execution.

Create a small evaluation set containing normal, edge, adversarial, and failure cases.

Score model behavior with explicit criteria while separating deterministic tests from model-based evaluations.

Trace an incorrect agent result through prompts, model responses, tool calls, logs, and configuration.

Implement prompt caching in the Anthropic API to reuse static context and reduce latency and cost.

Submit and manage asynchronous batch requests using the Anthropic Message Batches API.

Compare prompt caching, batching, streaming, and request reduction as optimization strategies.

Estimate the cost impact of context size, output length, retries, and tool-loop iterations.

Use evaluation results to make and verify one improvement to an end-to-end Claude application.

Choose an appropriate prompt, workflow, agent, tool, or MCP design for a scenario's constraints.

Diagnose design flaws in an end-to-end Claude application under security, cost, and performance constraints.

Apply a time-boxed, option-by-option verification method to a mixed set of multiple-choice and multiple-response questions.