Claude AI Certification Quiz

Welcome to your Claude AI Certification Quiz

Your lookup_order tool is being called with malformed inputs. About 6% of calls pass order IDs like "order-1234" or "#1234" instead of the bare numeric form the backend expects. The tool currently returns a generic {"error": "Order not found"} for these, and the agent then escalates the case. Which fix best matches the documented tool-design pattern?

Scenario 1: Customer Support Resolution Agent | Domain 2 — Tool Design & MCP

Add the agent's most-common malformations to a list in the system prompt and tell the model never to use those formats when calling the tool.

Strip non-numeric characters in the agent's prompt logic before calling the tool, so the tool only ever receives clean numeric IDs and the malformation problem is solved at the prompt layer reliably.

Have the tool accept any of the common formats, normalize internally, and return a structured error with error_code: "INVALID_FORMAT" and an explanatory message when normalization fails, so the agent can correct course rather than escalate.

Add a regex validator in front of the tool that rejects malformed IDs with HTTP 400 errors, forcing the agent's retry logic to re-attempt with a corrected ID format on the next iteration cycle.

You're deciding whether process_refund should be a single tool or split into two: initiate_refund (which puts the refund in a pending state) and confirm_refund (which commits it). Refunds above $200 require manager review under your policy. Which decomposition fits the documented agent-design principles best?

Scenario 1: Customer Support Resolution Agent | Domain 1 — Agentic Architecture

Keep process_refund as a single tool with an amount parameter, since the model can already reason about thresholds documented in the system prompt where it will see it on every turn.

Add a refund_type parameter to process_refund (immediate vs pending_review) and have the agent select the appropriate type based on the amount, simplifying the call surface to a single tool with explicit modes for handling.

Split into initiate_refund and confirm_refund because the two-tool decomposition mirrors the business policy: any refund passes through initiate, and confirm only runs for amounts below the manager-review threshold, enforced via a pre-tool-use hook on confirm_refund.

Split into initiate_refund and confirm_refund with no enforcement layer; the explicit two-step flow alone is sufficient to communicate the manager-review boundary to the agent through tool naming and documentation alone.

Your team is debating tool description style. One engineer writes terse descriptions ("Refunds an order"); another writes long ones with examples, edge cases, and explicit guidance on when to prefer this tool over alternatives. Production accuracy data shows the longer descriptions outperform terse ones by 8 percentage points on tool-selection correctness. What is the documented principle here?

Scenario 1: Customer Support Resolution Agent | Domain 2 — Tool Design & MCP

Tool descriptions should be terse to minimize token usage, since the model can infer behavior from the tool name and parameter signatures; the 8-point improvement is likely measurement noise in the production accuracy data.

The model treats tool descriptions like other context — it weights them more reliably when the system prompt also emphasizes their importance, so an "always read tool descriptions carefully" instruction is the load-bearing factor here.

Tool descriptions should optimize for tool-selection accuracy rather than token frugality — describing capabilities, inputs, edge cases, and "when to use this vs alternatives" in the description is the documented practice, and the 8-point gain reflects exactly this effect.

Long descriptions only help on small models; on Sonnet and above, the model can infer tool semantics from names and signatures alone, so the 8-point gain is a Haiku-specific phenomenon for that particular tier only.

Your agent's conversation summarization kicks in at 70% context utilization. After summarization, the agent occasionally forgets a billing exception it had agreed to mid-conversation ("we'll waive the late fee given the circumstances"). Spot-checking confirms the summarization step is condensing the agreement into something vague like "discussed billing concerns." Which approach addresses the root cause?

Scenario 1: Customer Support Resolution Agent | Domain 5 — Context Management & Reliability

Raise the summarization trigger threshold from 70% to 90% so the agent has more turns of detailed history before condensation kicks in and risks losing commitments made mid-conversation.

Maintain a parallel "commitments and exceptions" log that captures specific agreements (waivers, credits, promises) verbatim and is appended to the prompt on every turn, bypassing the lossy summarization path entirely.

Switch from extractive to abstractive summarization with a more detailed prompt that asks the summarizer to preserve any commitments, exceptions, and dollar amounts mentioned by the agent during the conversation history.

Reduce the agent's verbosity in earlier turns so that fewer tokens are consumed and summarization is triggered less often, leaving more room for commitments to remain visible in the unsummarized history naturally.

Your agent's loop reads each model response and decides whether to continue or terminate. A new engineer proposes a heuristic: "if the assistant's text contains a question mark, the model is asking the user something, so terminate the loop and wait for input; otherwise iterate." Initial testing looks promising. What is the architectural problem with this design?

Scenario 1: Customer Support Resolution Agent | Domain 1 — Agentic Architecture

Question marks are too common in normal model output — the heuristic will terminate prematurely on rhetorical questions ("Should we check the order first?") that aren't actually addressed to the user.

Loop control should be governed by the model-emitted stop_reason rather than by text-content heuristics; mixing inference-layer signals with surface-form parsing creates a brittle control flow that misbehaves on legitimate edge cases.

Terminating on question marks confuses the agent's ability to call multiple tools in sequence — the model would need to avoid all interrogative phrasing in its reasoning preamble, which is too restrictive a constraint.

Question-mark detection works in English but fails in localized deployments where punctuation varies; the heuristic needs locale awareness before it can be safely deployed to production reliably.

Your agent's resolution responses occasionally include speculative information not derivable from tool results — e.g., asserting a refund will arrive on a specific date when no tool returned a date. The model is confabulating timeline details when uncertain. Which intervention is the documented fix?

Scenario 1: Customer Support Resolution Agent | Domain 4 — Prompt Engineering

Increase the model tier from Sonnet to Opus, since confabulation is largely a capability question and more capable models hallucinate less under uncertainty for this kind of factual claim in production use.

Lower the model temperature to 0 to reduce sampling variance, since confabulation tends to occur more frequently at non-zero temperatures and zero temperature produces more conservative claims overall in this kind of setting.

Add a self-critique step after the agent drafts each response, asking it to verify each factual claim against tool results before sending; the agent can revise unsupported claims during this check before the response goes to the customer.

Add explicit grounding instructions: "Only state facts that appear in tool results. If a value isn't available, say so or call a tool — never speculate on timelines, amounts, or dates."

You're adding a new MCP tool get_account_balance(account_id). The backend returns {balance, currency, as_of_timestamp, pending_transactions[]}. The agent only needs balance and as_of_timestamp for the common "what's my balance?" question; pending_transactions is occasionally relevant. Returning everything bloats context across many turns. Which design fits?

Scenario 1: Customer Support Resolution Agent | Domain 2 — Tool Design & MCP

Return only {balance, as_of_timestamp} from get_account_balance and add a separate get_pending_transactions(account_id) tool the agent invokes when needed; lean defaults with a paired tool for the less-common case scenarios.

Return everything and instruct the agent in the system prompt to ignore pending_transactions unless the user specifically asks about pending charges, since the model can attend selectively to the relevant fields when needed.

Return {balance, as_of_timestamp, has_pending: bool, pending_summary: string} — the boolean and summary string convey whether pending transactions exist without the full payload, letting the agent decide whether to follow up next.

Return {balance, as_of_timestamp, pending_transactions} but configure the tool to truncate pending_transactions to the most recent 3 entries by default, capping the payload size at the source while preserving the field's availability when needed.

A customer escalation policy says: "If the customer indicates dissatisfaction, immediately route to a human." Your agent applies this — but production data shows ~14% of routed cases involved phrases like "this is frustrating" used about a product, not the agent's handling. Customers report they did NOT want a human; they wanted the agent to keep helping. What's the most appropriate refinement?

Scenario 1: Customer Support Resolution Agent | Domain 5 — Context Management & Reliability

Lower the sensitivity threshold by requiring two distinct frustration signals before escalation, so single-mention frustration about products doesn't immediately escalate to a human transfer in the system.

Add sentiment-classifier filtering to detect whether the frustration is directed at the agent versus the product, escalating only when the classifier identifies agent-directed dissatisfaction with high confidence threshold.

Keep the rule and have the agent ask "Would you like me to connect you with a human, or shall I continue helping?" whenever it detects dissatisfaction language, letting the customer decide rather than the agent inferring intent for them.

Remove "indicates dissatisfaction" as an automatic escalation trigger; replace it with an explicit signal like "requests human assistance" or "explicitly asks for escalation" — the original rule conflated emotion-about-product with desire-to-leave-the-agent.

Your team is onboarding a fourth developer to Claude Code. The existing three have personalized ~/.claude/CLAUDE.md files reflecting their individual preferences (preferred test framework, commit message style, verbosity). The new developer asks how to get started. What is the documented onboarding guidance?

Scenario 2: Code Generation with Claude Code | Domain 3 — Claude Code Configuration

The new developer should start with an empty ~/.claude/CLAUDE.md and let project-level CLAUDE.md (in the repo) provide team-shared context; personal preferences in ~/.claude/CLAUDE.md should be added gradually as the developer identifies them.

The new developer should copy one of the existing developers' ~/.claude/CLAUDE.md files as a starting point, since the team has implicitly standardized on certain personal conventions through informal adoption over time across the team.

The new developer should not maintain a ~/.claude/CLAUDE.md at all — personal preferences belong in the project's .claude/preferences/ directory checked into the repo, so the team can see and learn from each other's settings over time.

The new developer should configure their ~/.claude/CLAUDE.md exactly like the most senior developer's, since divergent personal configurations across team members produce inconsistent code review feedback and slow down PR turnaround across the team.

A regulatory requirement forces your agent to log a "decision rationale" with each refund issued — a short structured record of why the agent chose that resolution, what alternatives it considered, and what policy applies. The team wants the rationale generated as part of the resolution flow, not after the fact. Which design fits?

Scenario 1: Customer Support Resolution Agent | Domain 5 — Context Management & Reliability

Add a decision_rationale: {reasoning, alternatives_considered, policy_invoked} field to the process_refund tool's input schema, so the agent must populate it as part of the tool call and the rationale is captured atomically with the action.

Have the agent emit a free-text rationale into the conversation transcript before any refund tool call and rely on log aggregation to extract rationales from the conversation history after the fact for compliance purposes.

Add a separate log_decision_rationale tool the agent calls before any refund, with the system prompt instructing the agent to always invoke it; rely on the agent's instruction-following to produce rationale before any action runs.

Generate rationale post-hoc using a second model call that reviews the refund record and the prior conversation, then writes the rationale to a separate compliance store decoupled from the resolution flow as it executes.

You want Claude Code to automatically run pnpm install whenever a developer edits package.json. The action should fire on every save, not require manual invocation, and should happen regardless of which session is open. Which mechanism fits?

Scenario 2: Code Generation with Claude Code | Domain 3 — Claude Code Configuration

Create a .claude/commands/install-deps.md slash command and add a note to the project CLAUDE.md reminding developers to run /install-deps after editing package.json; rely on the convention being followed by team members consistently.

Add a pnpm install step to the project's .claude/skills/package-edit/SKILL.md skill and instruct developers to invoke /package-edit whenever they edit package.json, making the install step a documented manual workflow step in practice.

Configure a post-tool-use hook in the project's hook configuration that triggers pnpm install after any Edit or Write operation targeting package.json, making the action automatic and consistent across all sessions.

Add pnpm install to the project's git pre-commit hook so the dependency-install happens automatically when the developer commits the package.json change, decoupling it from Claude Code entirely as a separate workflow concern.

A developer is debugging a flaky CI job. They start a Claude Code session, examine logs, hypothesize a race condition, write a fix, and run the test 8 times to confirm it passes. The fix works. Two weeks later, the same flaky behavior returns. The developer wants to resume the prior diagnostic session to compare what they learned. Which best matches the documented pattern?

Scenario 2: Code Generation with Claude Code | Domain 1 — Agentic Architecture

Reload the relevant logs and ask Claude Code to re-derive the prior diagnosis; sessions are ephemeral and resuming an old session two weeks later is not reliable since file contents and tool versions may have shifted in between.

Use --resume to reload the prior session and ask Claude Code about the prior diagnosis directly; resumed sessions preserve the conversation history and findings even across long time gaps in between uses.

Use fork_session against the old session ID to create a new branch from the prior diagnostic state and continue exploration in the new branch without overwriting the historical record from the original session.

Start fresh and re-investigate from scratch; the two-week-old session's findings may have been invalidated by intervening code changes, and re-investigating from scratch is the safer path even if more time-consuming for the developer.

Your CLAUDE.md says "always use the team's logger (@/lib/logger) rather than console.log for instrumentation." A developer reports Claude Code repeatedly proposes console.log in debug code. Investigation reveals the developer's session has been open for 3 hours with many topic switches, and other instructions have accumulated in the prompt over time. Which is the most appropriate first step?

Scenario 2: Code Generation with Claude Code | Domain 3 — Claude Code Configuration

Add a more emphatic version of the logger rule ("ALWAYS use @/lib/logger, NEVER use console.log") near the top of CLAUDE.md to give it stronger weight in the prompt-attention ranking on the model's side.

Restart Claude Code to clear accumulated state, then verify the rule applies in a fresh session; long-running sessions are known to degrade adherence to early-loaded rules, and restart fixes that pattern reliably.

Move the logger rule from CLAUDE.md to a project-level skill that gets invoked when debug code is being written, so the rule activates exactly when relevant rather than always-on at all times during the session.

Run /memory to inspect which CLAUDE.md and rule files are currently loaded; the long session may have accumulated context that's drowning out the rule, and verifying load state is the first diagnostic step here.

You're using Claude Code's Task capability to spawn a subagent that runs a long-running codebase analysis (~6 minutes). The main session is meanwhile blocked waiting. You want the main session to remain responsive to short interactive questions from the developer while the subagent runs in the background. What is the documented limitation?

Scenario 2: Code Generation with Claude Code | Domain 1 — Agentic Architecture

Subagents always run in parallel with the main session; the issue must be a configuration problem with the developer's Claude Code setup that's serializing them inappropriately for this particular use case in their environment.

Task supports async fire-and-forget mode via a wait: false parameter, which lets the main session continue without blocking on the subagent's completion before responding to subsequent user turns and questions.

Long-running subagents can be detached with Ctrl-Z style suspension and returned to the foreground later when the developer wants to check progress, freeing the main session for other interactive work in between progress checks.

Task is synchronous: the main session blocks until the subagent completes. For long parallel work, run the analysis as a separate Claude Code invocation in another terminal instead.

You have an existing .claude/commands/test-fix.md slash command that runs the test suite and proposes fixes. A developer wants to extend it to also run npm run lint before testing. The change should be team-wide. Which approach matches documented practice?

Scenario 2: Code Generation with Claude Code | Domain 3 — Claude Code Configuration

Have each developer add a personal wrapper in ~/.claude/commands/test-fix-with-lint.md that invokes the project command after running lint, keeping the project command unchanged and respecting individual workflow preferences across the team.

Edit .claude/commands/test-fix.md directly to add the lint step before tests, submit it as a PR for team review, and merge once approved.

Create a new .claude/commands/lint-and-test-fix.md alongside the existing command so developers can choose which fits their current workflow; deprecate the old one gradually as the new one is adopted by the team over time.

Override the project command by creating a same-named ~/.claude/commands/test-fix.md that includes the lint step; user-level commands shadow project-level ones with the same name on each developer's machine across the team.

A customer reports an issue affecting their entire shipping history. Resolving it requires the agent to investigate orders going back 18 months — potentially 60+ lookup_order calls. The agent currently iterates through them one at a time and the conversation takes ~12 minutes. The investigation phase is "embarrassingly parallel" — each order lookup is independent. Which architectural change matches the documented parallelization pattern?

Scenario 1: Customer Support Resolution Agent | Domain 1 — Agentic Architecture

Increase the agent's tool-call timeout so individual lookup_order calls have more budget; the sequential bottleneck is per-call latency, and longer timeouts resolve the wall-clock problem effectively over time.

Have the agent emit multiple lookup_order tool calls in a single response — the SDK executes parallel tool calls within one model turn concurrently, dramatically reducing wall-clock latency for independent operations significantly.

Switch from lookup_order(order_id) to a paginated list_recent_orders(customer_id, limit, offset) and have the agent step through pages sequentially, since pagination is the standard pattern for "many orders" lookups in production.

Spawn 60 parallel subagents using Task, one per order ID, and have each subagent call lookup_order once before returning its result to the coordinator for aggregation across the parallel runs eventually.

A developer is using Claude Code to refactor a large module. After ~40 minutes, the session has accumulated detailed context about the module's structure, several reads of dependent files, and an evolving plan. The developer hits a confusing test failure and asks Claude Code to "diagnose this specific test failure." Claude Code's response weaves in details from the refactor planning that are irrelevant to the test failure. Which is the best fix?

Scenario 2: Code Generation with Claude Code | Domain 5 — Context Management & Reliability

Run /compact to summarize the refactor context while preserving its key findings, reducing the noise; the test diagnosis runs in the same session with a cleaner context state to work from afterwards in the session.

Scope the question more explicitly using the @ reference to point Claude Code at the specific test file and let the broader refactor context fall away naturally from the model's attention over the course of the response.

Start a fresh Claude Code session for the test diagnosis, passing only the specific test file and the failure output as context; the refactor session can be --resumed later when the developer wants to return to it.

Increase the model's max_tokens budget to give it more room to reason and produce a focused diagnosis despite the accumulated context; broader context just needs more output budget to navigate effectively for the developer.

Your team's .claude/rules/conventions.md uses paths: ["src/**/*.ts"] to scope TypeScript rules to source files. A developer reports that when they edit a .ts file inside __tests__/ directories, the conventions don't load — but they want test files to also follow these conventions. What's the right change?

Scenario 2: Code Generation with Claude Code | Domain 3 — Claude Code Configuration

Add paths: ["**/__tests__/**/*.ts"] as a separate include in the same rule file, so test directories are also matched by the existing rules without changing the source-file glob currently in place.

Add paths: ["src/**/*.ts", "**/__tests__/**/*.ts"] to the rule file's frontmatter so both source files and test files inside __tests__/ directories are matched by the glob array, applying conventions to both contexts.

Move the rules into the project root CLAUDE.md so they always load regardless of file path, eliminating the path-scoping issue entirely by removing the path filter from the equation altogether for these specific rules.

Change the glob to paths: ["**/*.ts"] so all TypeScript files match regardless of directory, applying the conventions universally to the codebase wherever TypeScript code is being edited at any point in time.

Your project's .mcp.json includes a server internal-tools that the team uses heavily. A new contractor joining temporarily should not have access to internal-tools but should have access to all other configured servers. The contractor will work in the same repo. What is the documented mechanism?

Scenario 2: Code Generation with Claude Code | Domain 3 — Claude Code Configuration

Remove internal-tools from .mcp.json entirely while the contractor is working, then re-add it after the contract ends; the temporary inconvenience to the team is offset by the simplicity of the approach in practice.

Move internal-tools out of .mcp.json (project-scoped) and into each team member's ~/.claude.json (user-scoped); the contractor simply doesn't add it to their own user config, while the rest of the team continues using it normally.

Add a permissions block to .mcp.json's internal-tools entry listing allowed users; the contractor will be excluded by username and unable to invoke that server's tools while still seeing them listed in the file.

Fork the repository for the contractor's work and remove internal-tools from the fork's .mcp.json; merge their changes back into the main repo without merging the .mcp.json change in particular.

Your team uses plan mode for architectural changes. A developer in plan mode produces a comprehensive plan over 25 minutes. The plan is solid but execution will touch ~40 files. The developer wants to execute the plan in stages with checkpoints, so they can review progress and back out if things go wrong. Which workflow fits?

Scenario 2: Code Generation with Claude Code | Domain 1 — Agentic Architecture

Execute the entire plan in one pass within the same session that produced the plan, since the model has full plan context and stage-by-stage execution adds session-management overhead without quality benefit for this case.

Switch to direct execution within the same session and prompt the model to execute one stage at a time, manually pausing between stages to review; the model's plan context is preserved throughout each pause and resume cycle.

Save the plan to a file, switch to direct execution, and ask Claude Code to execute "stage 1 of the plan in @plan.md," then repeat for each stage; the file-anchored plan keeps each stage's instructions explicit and reviewable thoroughly.

Use fork_session between each stage so each stage has its own branch, then if a stage goes wrong revert to the prior branch; the forks preserve checkpoints automatically without manual file management overhead at all.

Unleashing Cognitive Potential: The Evolution of Modern Child Development Methodologies

How to Prepare Your Piano for a Safe Move in Richmond, VA

North Shore Skip Bins is The Answer To Your Skip Bin Problems

How Limotak Marketplace Pricing Actually Works

How to Spend 3 Days in Egypt: A First-Time Visitor’s Itinerary

Why Guest Blogging Matters for SEO

When Is the Best Time to Take Collagen Protein Powder?