Free Claude certification practice questions

Answer: D. Read-heavy research where independent sources can be explored simultaneously and each subagent returns a condensed summary

Parallel subagents shine on parallelizable, self-contained, read-heavy work: each worker explores independently in its own context and returns compressed findings. Sequential dependencies eliminate the parallelism benefit, tasks requiring continuously shared state incur heavy coordination overhead, and quick targeted edits are better done in the main conversation because subagents start fresh and add latency.

Answer: A. The tool call is blocked, and the hook's stderr output is fed back to Claude as an error message

Exit code 2 from a PreToolUse hook is a blocking error: the tool call is prevented and the stderr text is returned to Claude so it understands why the action was rejected. Stdout, including any JSON, is ignored on exit code 2; JSON decisions like permissionDecision are only processed when the hook exits with code 0. There is no automatic retry behavior for hooks.

Answer: D. Gather context, take action, verify work, then repeat.

Anthropic describes the agent loop as gathering context, taking action, verifying work, and repeating until the task is done. Classify-and-route describes the routing workflow, not the agent loop, and generate-then-evaluate describes evaluator-optimizer. Planning everything upfront and terminating contradicts the iterative, feedback-driven nature of agents.

Answer: D. Sectioning, which breaks a task into independent subtasks run in parallel, and voting, which runs the same task multiple times to get diverse outputs.

Anthropic names exactly two parallelization variants: sectioning (independent subtasks in parallel) and voting (the same task run multiple times for diverse outputs). Routing is a separate workflow pattern and gates belong to prompt chaining, not parallelization. Sharding, batching, and map-reduce are general distributed computing terms that Anthropic does not use for this pattern.

Answer: A. It is a client-side tool: Claude requests operations such as view and create, and the developer's application executes them against storage the developer controls.

The memory tool operates client-side: Claude only emits tool_use requests, and your application executes each command against its own storage, returning results in tool_result blocks. The /memories path is just a prefix your handler maps onto real storage such as a per-user directory or database keys. Anthropic does not host the files, there is no managed vector database behind it, and it has no dependency on the code execution tool.

Answer: D. Failures are easier to trace and debug because there is one context and one decision-making loop instead of coordination across multiple agents.

With one agent there is a single trajectory to inspect, so debugging and tracing are simpler and cheaper than reconstructing interactions among an orchestrator and multiple subagents. Breadth-first research exceeding one context window is exactly where multi-agent systems excel, single agents remain non-deterministic across runs, and long-running single agents are still stateful systems where errors compound, so observability is still required.

Answer: D. In an isolated environment such as a container or VM where the agent cannot damage systems that matter

The docs warn that bypassPermissions skips permission prompts and should only be used in isolated environments like containers or VMs where Claude Code cannot cause damage. CLAUDE.md instructions shape model behavior but are not an enforced boundary, so they do not make the mode safe on a workstation. Monitoring a production session does not contain the blast radius of a mistaken action, and git does not protect files outside the repository or actions like network calls.

Answer: B. Agentic systems often trade higher latency and cost for better performance on complex tasks, so teams must evaluate when that tradeoff makes sense.

Anthropic states that agentic systems often trade latency and cost for better task performance, and developers should consider when this tradeoff makes sense. Splitting work across calls increases rather than decreases total tokens and wall-clock time, agents are used precisely because complex tasks demand correctness, and autonomous behavior increases (not removes) the need for evaluation and guardrails.

Answer: C. A permission rule that denies Claude the ability to run a specific shell command

Permission rules like permissions.deny are technical enforcement applied by the Claude Code client regardless of what the model decides, so they belong in settings files. CLAUDE.md content is context that guides behavior but is not guaranteed to be obeyed. Build commands, naming conventions, and architecture overviews are exactly the kind of natural-language guidance CLAUDE.md is designed to carry.

Answer: A. Lists all CLAUDE.md, CLAUDE.local.md, and rules files loaded in the session and lets you open them in your editor, plus toggle auto memory

The /memory command is the inspection and editing entry point for memory: it shows every memory file loaded in the current session, opens any of them in your editor, and includes the auto memory toggle. Clearing context is handled by /clear or /compact, not /memory. It does not produce token usage reports, and it never writes the conversation itself into CLAUDE.md.

Answer: C. Holding personal, project-specific instructions (like sandbox URLs or preferred test data) that are added to .gitignore rather than committed

CLAUDE.local.md is for individual, per-project preferences: it loads alongside the project CLAUDE.md and should be gitignored so it stays private to you. It does not override or disable the shared CLAUDE.md; both files are combined into context. There is no --local launch flag gating it, and organization-wide policy belongs in the managed policy CLAUDE.md location, not in a per-developer local file.

Answer: B. name and description

Only name and description are required in subagent frontmatter; the Markdown body then becomes the subagent's system prompt. Fields like tools, model, and permissionMode are optional: omitting tools inherits all tools from the main conversation, and omitting model falls back to the session's model. The description is required because Claude uses it to decide when to delegate.

Answer: A. Analyzes the codebase and generates a starting CLAUDE.md with discovered build commands, test instructions, and conventions; if one already exists it suggests improvements instead of overwriting it

/init bootstraps project memory by exploring the codebase and writing a CLAUDE.md that captures build commands, test instructions, and project conventions, and when a CLAUDE.md already exists it proposes improvements rather than overwriting. It is a memory-generation command, not a settings or permissions generator. It never destroys an existing file, and it has nothing to do with Console registration.

Answer: D. An @ prefix followed by the path, for example @docs/git-instructions.md

CLAUDE.md supports @path/to/import syntax, so writing @docs/git-instructions.md anywhere in the file expands that file into context at launch. Both relative and absolute paths are allowed. The templating, #include, and markdown-link forms are plausible-looking inventions that Claude Code does not recognize as imports.

Answer: B. Read-only operations such as file reads and Grep searches

Claude Code uses a tiered permission system in which read-only tools like file reads and Grep never require approval. Bash commands and file modifications both require approval in default mode: Bash approvals persist per project directory and command only when you choose the don't-ask-again option, and file edit approvals last until the session ends. There is no automatic session-wide trust for previously used commands or domains.

Answer: C. The developer notices they are typing the same correction into chat that they typed in a previous session

The docs frame CLAUDE.md as the place to write down what you would otherwise re-explain: repeated corrections, repeated mistakes, and context a new teammate would need. Long multi-step procedures or narrowly scoped guidance belong in skills or path-scoped rules instead, keeping CLAUDE.md concise. Secrets should never go in a memory file, and anything requiring guaranteed enforcement belongs in settings (permissions or hooks), not in context.

Answer: C. Most batches complete in less than 1 hour, but processing can take up to 24 hours, after which the batch expires.

The system processes each batch as fast as possible: most batches finish in under 1 hour, and results become available when all requests complete or after 24 hours, whichever comes first. Batches that do not finish within 24 hours expire. There is no scheduled nightly window, no 1-hour guarantee, and no unbounded processing.

Answer: A. It lists custom text strings that cause generation to stop as soon as the model produces one of them

stop_sequences defines custom strings that end generation the moment the model produces one; the matched string is excluded from the returned text and reported in the response's stop_sequence field. The parameter does not filter phrases while generation continues, does not split content blocks, and nothing is appended to the output.

Answer: B. It ranges from 0.0 to 1.0 and defaults to 1.0; values closer to 0.0 suit analytical or multiple choice tasks, while values closer to 1.0 suit creative and generative tasks.

The Messages API documents temperature as defaulting to 1.0 with a 0.0 to 1.0 range, recommending lower values for analytical tasks and higher values for creative ones. The 0.0 to 2.0 range with a 0.7 default describes other providers' APIs, not Claude's, and higher temperature increases rather than reduces randomness. The default is not 0.0, and the integer candidate-count description matches top_k, not temperature.

Answer: D. Up to 100,000 Messages requests or 256 MB in total size, whichever is reached first.

The documented limit is 100,000 Messages requests or 256 MB per batch, whichever comes first. There is no requirement that requests share a model or parameters: each request in a batch carries its own independent params object, and there is no unlimited-size tier.

Answer: C. Including a few well-crafted example inputs and outputs directly in the prompt to steer Claude's format, tone, and structure

Multishot (few-shot) prompting means placing a few well-crafted examples in the prompt itself, which the docs call one of the most reliable ways to steer output format, tone, and structure. Re-running a prompt and comparing outputs is best-of-N verification, splitting work across calls is prompt chaining, and the Messages API has no parameter that returns multiple candidate completions.

Answer: C. end_turn: the model reached a natural stopping point and finished its response on its own.

end_turn means the model completed its turn naturally and the response can be used as-is. max_tokens signals the output hit the requested token cap (safety declines surface as the refusal stop reason), and tool_use means the model is requesting that your application execute a tool, not that execution already finished. stop_sequence indicates one of your custom stop_sequences was generated; rate limiting is reported as an HTTP 429 error, never as a stop_reason.

Answer: B. Claude must actually output its reasoning in the response; without outputting its thought process, no thinking occurs

Anthropic's chain of thought guidance stresses always having Claude output its thinking, because without the thought process appearing in the output, no thinking occurs. That rules out silent internal reasoning while emitting a one-word reply. Manual CoT is a prompting technique that works without the extended thinking API feature, and CoT instructions work in user messages as well as system prompts.

Answer: D. Code-based grading is fastest and most reliable but lacks nuance; human grading is flexible and high quality but slow and expensive; LLM-based grading is fast and scalable but should be tested for reliability before scaling.

The docs rank code-based grading (exact match, string match) as fastest, most reliable, and extremely scalable but lacking nuance; human grading as most flexible and high quality but slow and expensive, to be avoided when possible; and LLM-based grading as fast, flexible, and suitable for complex judgment once reliability is validated. The other options invert these tradeoffs: humans are the slow path, LLM grading exists precisely for nuanced judgments, and code rules cannot capture every subjective assessment.

Answer: B. vector_db-search_v2

Tool names must match the regex ^[a-zA-Z0-9_-]{1,64}$: only ASCII letters, digits, underscores, and hyphens, with a length of 1 to 64 characters. Spaces, periods, and accented or other non-ASCII characters are all rejected, which rules out the other three options. Underscores and hyphens are both permitted, so mixing them as in the correct option is fine.

Answer: A. Aim for at least 3 to 4 sentences per tool, and more for complex tools

The documentation says to aim for at least 3 to 4 sentences per tool description, and more for complex tools. Ultra-short descriptions appear as the poor example in the docs, the API does not truncate description text at any short word count, and Claude weighs the description heavily rather than relying on input_schema alone.

Answer: D. Tools, resources, and prompts

MCP servers expose tools (executable functions), resources (data sources for context), and prompts (reusable templates). Sampling, roots, and elicitation are the primitives exposed by clients, not servers, while hooks and skills are Claude Code concepts rather than MCP protocol primitives.

Answer: A. Aim for at least 3-4 sentences per tool description, and more when the tool is complex

The documentation recommends at least 3-4 sentences per description, with more detail for complex tools. Descriptions are injected into the tool use system prompt and strongly influence behavior, so they are not inert metadata. The docs' "poor description" example is exactly the terse one-liner style, which leaves Claude with open questions about usage.

Answer: B. An id to match results to the call, the name of the tool, and an input object conforming to the tool's input_schema

A tool_use block carries an id used to match the eventual result, the name of the tool, and an input object that conforms to the tool's input_schema. tool_use_id, content, and is_error are fields of the tool_result block you send back, not of tool_use. There is no output field because the API does not execute client tools, and input arrives as a parsed JSON object rather than an encoded arguments string.

Answer: D. The client launches the server as a subprocess and exchanges newline-delimited JSON-RPC messages through the server's standard input and standard output.

In the stdio transport the client launches the server as a subprocess, writes JSON-RPC messages to the server's stdin, and reads responses from its stdout, with messages delimited by newlines. WebSockets, shared memory, and Unix domain sockets are not part of the two standard MCP transports, which are stdio and Streamable HTTP.

Answer: B. JSON-RPC 2.0, with requests, responses, and notifications encoded as UTF-8 JSON.

MCP's data layer is built on JSON-RPC 2.0, and every transport (stdio, Streamable HTTP, or a custom transport) must preserve that message format, encoded as UTF-8. MCP is not defined in terms of Protocol Buffers, REST resource semantics, or GraphQL, even though Streamable HTTP happens to use HTTP as a carrier.

Answer: D. name, description, and input_schema (a JSON Schema object describing the tool's expected parameters)

Each custom tool in the tools parameter is defined by a name, a description, and an input_schema expressed as JSON Schema; an optional input_examples array can also be added. The API never invokes your code directly, so there is no endpoint, HTTP method, or handler to register: your application executes the tool when Claude emits a tool_use block. The function_name/arguments/return_type shape belongs to other providers' APIs, not the Claude Messages API.

Answer: A. The total amount of text the model can reference when generating a response, including the response it generates, functioning as its working memory

The docs define the context window as all the text a model can look back on and reference when generating a response, plus the new text it generates, acting as working memory. It is explicitly distinct from the training corpus. The Messages API is stateless and does not maintain a server-side conversation cache, and max_tokens caps output length rather than defining the window.

Answer: A. The system prompt, tool definitions, every message in the conversation (including tool results and documents), and the output Claude generates for the turn, including its extended thinking

Everything in the request counts toward the window: the system prompt, tool definitions, and all messages including tool results and documents, plus the output generated for the turn, including current-turn thinking. Output shares the same window as input, so max_tokens must fit in the remaining space. Cached tokens still occupy the window; prompt caching changes what you pay for those tokens, not whether they count.

Answer: A. It summarizes the conversation history and replaces the older transcript with that summary, freeing context so the session can continue

/compact performs compaction: Claude Code summarizes the conversation and continues from the condensed summary, and you can even steer it with custom instructions such as /compact Focus on code samples and API usage. Wiping the whole history is what /clear does. Summarization is lossy by design, not lossless compression, and the model's context window size is a fixed model property that commands cannot shrink.

Answer: A. 200,000 tokens

Claude Sonnet 4.5 and most Claude models ship with a 200K token context window as the standard size. A 1M token window exists only for specific models and, for Sonnet 4.5, required opting in through a long-context beta header, so it is not the default. 100K was the ceiling of much older Claude generations, and 500K is not an offered context size.

Answer: D. POST /v1/messages/count_tokens, which accepts the same request shape as message creation (model, system, tools, messages) and returns an input_tokens count

The token counting endpoint mirrors the Messages request structure, including system prompts, tools, images, and PDFs, and returns the total input token count. It is free to use, subject to its own requests-per-minute limits separate from the Messages API, and the count is an estimate that may differ slightly from actual usage. The other two endpoints and the dry_run parameter do not exist in the Claude API.

Answer: B. Find the smallest possible set of high-signal tokens that maximizes the likelihood of the desired outcome

Anthropic's context engineering guidance states that context must be treated as a finite resource with diminishing marginal returns, and that good context engineering means finding the smallest possible set of high-signal tokens that maximize the likelihood of the desired outcome. Packing the window with everything available degrades recall rather than improving it. There is no documented rule that attention stops at 50 percent of capacity.

Answer: C. Curate the smallest possible set of high-signal tokens that maximizes the likelihood of the desired outcome

Because model attention degrades as token count grows (a phenomenon the docs call context rot), the guidance is to find the smallest set of high-signal tokens that supports the task. Packing the window, front-loading every document instead of retrieving just in time, and assuming a larger window removes the need for curation all ignore the diminishing returns of added context.

Answer: B. 200,000 tokens, shared between the input prompt and the generated output

Claude Sonnet 4.5 has a standard 200k-token context window that holds both the input and the output the model generates. The 1M token window is a separate beta capability limited to eligible models and higher usage tiers, not a default. The window is a single shared budget rather than separate input and output pools, and max_tokens caps output length without enlarging the window.