CCAR-F practice questions, free.

A support desk needs incoming tickets sorted into five fixed categories and routed to the matching queue. Which design fits best?

• An evaluator-optimizer loop that proposes a category and revises it until a second judge call agrees
• A single autonomous agent with the queue tools attached, deciding per ticket where it should go
• A routing workflow with one classification call, then a fixed handoff to the queue for that category
• An orchestrator that spawns five subagents and lets each one claim the tickets it judges to be in scope

A task requires editing an unknown number of files across a repository, and the set of files cannot be predicted until the work is under way. Which pattern applies?

• Parallelization with a worker per file type, each scanning its share of the tree for changes to make
• Prompt chaining with one step per directory, so every part of the repository gets its own fixed pass
• Orchestrator-workers, with a coordinator that discovers the subtasks during the run and delegates each one
• A single call with the full repository loaded into context, asking the model to return every edit in one response

A translation pipeline produces drafts that a reviewer can grade against clear criteria, and quality improves when feedback is applied. Which pattern matches?

• Routing by language pair, so each pair reaches a specialist prompt tuned with curated examples for that pair
• Parallelization across sentences, with each worker translating a slice and a final merge step
• Evaluator-optimizer, where one call drafts, a second grades against the criteria, and the loop repeats
• A single agent with a translation tool that it calls once per document and returns the result

An agent can issue refunds. The business wants any refund above $500 approved by a person. Where should that rule live?

• In a permission check or hook that intercepts the refund tool call and blocks it until a person approves
• In a weekly review of the refund log, so any refund over the limit is caught and reversed if it turns out to be wrong
• In the system prompt, as a rule telling the model to pause and ask before any refund above the limit
• In the refund tool's description, so the model reads the threshold every time it considers the tool

A tool that creates invoices sometimes times out, and the agent retries. Customers are receiving duplicate invoices. Best fix?

• Make the tool idempotent with a client-supplied request id, so a repeated call returns the same invoice
• Raise the tool's timeout so that slow invoice runs finish before the agent loop gives up on the call and retries
• Add a system prompt rule that the model should retry only after checking the invoice list first
• Move invoice creation out of the tool and into a post-run batch job that dedupes by customer

During a long multi-agent run one tool starts returning errors on every call, and the coordinator keeps re-issuing the same request. What is missing?

• A stronger model for the coordinator role so it notices the pattern and changes its approach
• A larger context window for the coordinator so the earlier error results stay visible to it
• Bounded retries with backoff and a circuit breaker that stops calling the tool after repeated failures
• A system prompt instruction telling the coordinator to switch to a different tool as soon as it sees an error result

What belongs in a project's CLAUDE.md file?

• Build and test commands, project conventions, and gotchas Claude needs on every task, kept short
• Environment variables and service credentials the project needs, so Claude can run commands without asking
• The full architecture documentation and API references, so Claude has complete knowledge in every session
• A running log of past sessions and their outcomes, so Claude can pick up where the last one ended

A team wants every file Claude Code edits to be run through the formatter, without relying on the model to remember. Which mechanism is right?

• A custom slash command that formats the tree, which the developer runs at the end of a session
• A formatting subagent that the main session delegates to once the edits are complete
• A CLAUDE.md instruction asking Claude to run the formatter after each edit it makes
• A PostToolUse hook matched to the edit tools that runs the formatter on the changed file

How would you run Claude Code non-interactively inside a CI job?

• A subagent launched from a developer's local session, with the CI job waiting on its result
• Print mode with the -p flag, passing the prompt and a restricted allowed-tools list
• An interactive session on the runner with the permission mode set to accept every action
• A plan-mode session, since planning does not edit files and so needs no approvals

A session has been running for hours and answers are getting worse and slower. What is the first thing to try?

• Switch the session to a larger model so it can hold more of the accumulated conversation
• Paste the full transcript so far back in as a new user message so nothing is lost
• Compact or clear the context, then re-brief the task with only what the next step needs
• Disable hooks for the rest of the session, since each hook adds latency to every tool call

You need a response in a strict JSON shape that downstream code will parse. Which approach is most reliable?

• Lower the temperature to zero so the formatting is deterministic across runs
• Define the shape as a tool input schema, or use structured outputs, so the model must conform
• Ask for JSON in the user message and add a note that any text outside the object will break the parser
• Prefill the assistant turn with an opening brace and stop at the closing brace

A prompt includes a 40-page contract and one question about it. Where should the question go?

• In the system prompt, with the contract alone in the user turn, so instruction and content are separated
• Split across several user turns, one section of the contract per turn, with the question at the end
• At the end of the user message, after the contract, with the contract clearly delimited by tags
• At the top of the user message, before the contract, so the model knows what to look for while it reads

Output format keeps drifting despite detailed instructions. What usually fixes it fastest?

• Remove the system prompt and put the instructions in the user turn, closer to the task
• Add two or three high-quality examples of the exact format, wrapped in clearly labeled tags
• Reduce max_tokens so the model has no room to add anything beyond the required format
• Restate the format instruction at both the start and the end of the prompt so it is harder for the model to miss

When is extended thinking the wrong tool?

• Multi-step planning over a set of requirements that conflict with one another
• Debugging a subtle logic error across several interacting functions
• Weighing the trade-offs between two candidate system architectures
• A high-volume yes/no classifier where per-request cost and latency dominate

A tool named q with the description "queries db" is being called at the wrong times with the wrong arguments. Best fix?

• Add separate tools for each common query so the model no longer has to work out the arguments
• Rename it and write a description covering when to use it, what each parameter means, and edge cases
• Add a system prompt rule that the model should think carefully before every database query
• Return a longer error message from the tool whenever the arguments do not match a known query

You need the model to call one specific tool on this turn, no matter what. Which setting?

• tool_choice set to auto with the tool listed first in tools
• disable_parallel_tool_use set to true and one tool listed
• tool_choice set to that tool by name, forcing the call
• tool_choice set to any, so the model must call some tool

An MCP server will run on the developer's own machine, launched by the client as a child process. Which transport?

• WebSockets over a public URL
• Server-sent events endpoint
• stdio over the child process
• Streamable HTTP on localhost

A tool call fails because the record does not exist. What should the tool return so the agent can recover?

• A successful empty result, so the loop continues and the model infers the record was missing
• No result for that call, holding the turn until a person can look up the record by hand
• A tool result flagged as an error, with a message saying the record was not found and what ids are valid
• The raw exception and stack trace from the database driver, so the model can see exactly which query failed

You want prompt caching to work across many requests that share a large system prompt and tool set. How should the prompt be ordered?

• Volatile user content first, then the system prompt and tool definitions, with a cache breakpoint at the very end
• Everything inside one user message in a fixed order, so the whole request is cached as one block
• Tools first, then the user content, then the system prompt, with a breakpoint after each section
• Stable content first (system prompt, tool definitions), a cache breakpoint after it, volatile content last

A coordinator delegates research to a subagent. What should the coordinator pass, and what should it get back?

• The whole conversation so far, and the subagent's complete transcript back, so nothing is lost
• A pointer to the coordinator's memory file, and the subagent's full transcript back for review
• A complete, self-contained brief with everything the subagent needs, and only the conclusion back
• A one-line task title, since the subagent shares the coordinator's context and can look up the rest

A document pipeline runs the same three steps on every input: extract entities, normalize them, then write a summary. Each step's output feeds the next. Which pattern is this?

• Orchestrator-workers, with a planner assigning steps
• Evaluator-optimizer over the summary step
• Parallelization, with the three steps run at once
• Prompt chaining, with each output feeding the next

Three independent checks (toxicity, PII, and policy) must run on every response before it is shown. Latency matters. Which pattern?

• Have one classifier call decide which checks are needed
• Fold all three checks into a single call with one prompt
• Chain the checks in sequence so each one sees the previous verdict
• Run the three checks concurrently and aggregate the verdicts

When does Anthropic's guidance say to reach for an agent instead of a workflow?

• When the task is large enough that a single prompt cannot hold all of the input
• When the number of steps cannot be predicted and the model must choose its path from results
• When latency is not a concern and the budget comfortably allows several model calls for each request
• When the steps are known in advance but each step needs a different model

An agent for booking travel has succeeded in demos but sometimes loops forever in production. The most important missing control is:

• A maximum turn count and a stop condition the loop checks on every iteration
• A larger context window so earlier attempts remain visible and are not repeated
• A wider tool set so the agent has an alternative route when one provider fails
• A more detailed persona and goal statement so the agent stays focused on the booking

Which is the strongest reason to start a new client project with workflows rather than agents?

• Workflows can be built without prompt engineering, so the client's own team can maintain them
• Workflows are what stakeholders expect and are easier to present in a demo
• Workflows are predictable, testable, and cheaper, building the trust needed before autonomy
• Agents require the Agent SDK, which most client environments cannot run

An orchestrator delegates research to three subagents and then writes a report. One subagent returns nothing useful. What should the design do?

• Drop that topic from the report and note in the log that the subagent returned no content
• Hand the empty topic back to the user with a question about whether the report should continue
• Detect the gap, retry or re-scope the subtask, and proceed with what it has when retries run out
• Fail the whole run and surface the empty result, since a partial report could mislead whoever reads it

A coding agent must never run a destructive git command. Which enforcement is reliable?

• A CLAUDE.md section describing which git operations are off limits in this repo
• A PreToolUse hook or permission rule that blocks matching commands before they execute
• A lower temperature setting so the agent sticks to the conservative commands it has already seen
• A system prompt rule listing every destructive git command the agent must not run

You are asked to justify why an agent design uses a single coordinator instead of a swarm of peer agents that message each other freely. The best justification:

• Peer messaging is slower in practice because every message needs its own model call
• A coordinator keeps control flow observable and debuggable, and bounds each subagent's context
• Peer agents cannot share tool results, so a coordinator is needed to relay them
• The API's multi-agent support is built around a single coordinator, so peer swarms need extra scaffolding

A customer wants an agent that autonomously sends emails on their behalf. What belongs in the first release?

• Autonomous sending for all emails except the ones the model itself flags as sensitive
• Draft-then-approve: the agent prepares emails and a person sends, with autonomy earned on measured accuracy
• Autonomous sending for internal recipients only, expanding to external once a week has passed
• Full autonomy from day one, with a daily audit of what was sent so problems are caught early

Which metric best tells you an agent is worth its cost in production?

• Average tokens consumed per completed task, trended week over week
• Number of tasks handled per day compared with what the human team handled before
• Task completion rate at acceptable quality, measured per dollar and per minute
• Share of runs that finish without any tool errors or retries

An evaluator-optimizer loop keeps running for many iterations without converging. What is the likely design flaw?

• The evaluator's criteria are vague, so 'good enough' is never reached; it needs pass criteria and a round cap
• The loop has no memory of earlier drafts, so it keeps repeating the same corrections
• The generator runs at too high a temperature, so each draft moves in a new direction
• The evaluator and generator share a prompt, so the judge is biased toward its own output

A routing workflow classifies requests into billing, technical, and sales. Ten percent of requests fit none. What should the design include?

• A fourth category learned from the unclassified requests after launch
• Retry classification with a second model until every request lands in one of the three
• A fallback route for 'other' that goes to a general handler or to a person
• A confidence threshold that forces low-confidence requests into the nearest bucket

Which statement about tools in agent loops is correct?

• Tools must be called in the order they are listed, so ordering in the tools array matters
• Tool results are data the model reasons over; instructions come from the system prompt and user
• Tool results can only carry text, so binary or structured data must be described in the prompt
• Tool results should be passed back as a user turn so that the model treats them as fresh instructions to follow

A team wants to run twenty subagents in parallel for a research task. What should they watch first?

• That each subagent has a complete, self-contained brief and a bounded budget
• That every subagent uses the same tool set so the results have a common shape
• That the coordinator holds no context of its own and only merges the results
• That all subagents share one context window so they do not duplicate work

An agent must decide between continuing a task and asking the user a question. Good design says it should ask when:

• Any tool call in the current step has returned an error
• It has consumed half of its token budget for the task at hand
• It has finished one subtask and the next one on the list belongs to a different owner
• The next action is irreversible, ambiguous, or outside its granted scope

A workflow uses one large model call to do classification, extraction, and a summary at once, and quality is uneven. What is the usual improvement?

• Decompose into chained steps so each call has one job and can be checked
• Drop the summary from the call and generate it separately with a template
• Switch to a larger model so it can handle the three tasks in one pass
• Enable extended thinking so the model plans all three outputs before writing

What is the practical reason to log every tool call, its inputs, and its result in an agent system?

• Cost control, since tool call logs are the only way to reconstruct token usage per task
• Prompt caching, since logged calls can be replayed as a cached prefix on the next run
• Debugging, evaluation, and audit: you cannot improve or explain behavior you did not record
• Compliance reporting, since most regulated industries require a record of automated actions

A client says 'make it fully autonomous' for an agent that changes production database records. Your recommendation as the architect:

• Full autonomy as requested, with a nightly database backup so any bad change can be restored
• Full autonomy with logging turned off in the hot path so approval latency does not slow the agent
• Read-only access for the agent, with all writes handled by a separate scheduled job the client owns
• Autonomy for reads and reversible changes, approval for irreversible ones, with an audit trail, revisited as data comes in

A developer complains Claude Code re-explores the codebase every session. The cheapest fix is:

• A subagent that explores the codebase and reports back at the start of each session
• A memory file the developer pastes into the first message of every session
• A longer first prompt each session that walks through the directory layout
• A CLAUDE.md with the project's structure, commands, and conventions

You want Claude Code to plan before it edits on a large refactor. Which feature matches?

• Plan mode, which explores and proposes an approach before any file changes
• Headless mode with a prompt asking for a written plan and no tool access
• A PreToolUse hook that rejects edit calls until a plan file exists in the repository
• A custom slash command that runs the test suite before each edit is applied

A repeated workflow, 'update the changelog from recent commits', should be one command. Which Claude Code feature?

• A subagent dedicated to changelog work, invoked from the main session
• A PostToolUse hook on git commit that appends the message to the changelog
• A custom slash command or skill that captures the prompt and steps
• An MCP server exposing a changelog tool that reads the git history

Which permission approach is right for a shared CI runner using Claude Code?

• Accept every tool call automatically, since no developer is present to approve
• Deny every tool so the run is a pure text response with no side effects
• An explicit allow list of tools and commands, with no interactive approvals
• Prompt the developer who pushed the commit for each tool approval via chat

Where does an MCP server configuration belong when it should apply to everyone working in the repository?

• In each developer's user-level settings, synced through a dotfiles repository
• In the project-scoped configuration checked into the repository
• In a SessionStart hook that registers the servers when Claude Code launches
• In the system prompt for the session, listed as servers Claude should connect to

A hook that blocks a tool call should communicate the reason. Why?

• So the block is written into the transcript for the developer to review later on
• So the hook's exit code can be mapped to the right billing category
• So the model can override the block when the reason does not apply
• So the model can adjust its plan instead of retrying the same blocked action

Which task is a good fit for a Claude Code subagent?

• A large, self-contained investigation whose details would clutter the main session
• Changing the permission settings so the main session can run a tool
• Reading CLAUDE.md at the start of a session and summarizing its rules back to the user
• Applying a one-line change that the main session has already located

A team notices Claude Code sometimes runs the test suite three times in a row. Which is the right lever?

• Removing the test command from the allowed tools and running tests in CI instead
• Increasing the max turns so the session can finish before the loop is cut off
• A hook or CLAUDE.md rule defining when tests run, plus a check of the loop for missing stop conditions
• A stricter system prompt telling Claude to run the tests only once per task

What does the /compact style operation do in a long session?

• Trims tool results from the transcript but keeps every user and assistant turn
• Summarizes the conversation so far to free context while keeping the essentials
• Switches to a model with a larger window so the session can continue
• Restarts the session with the same CLAUDE.md loaded and an empty conversation history

A developer wants Claude Code to stop before committing so they can review. Best approach?

• A CLAUDE.md line asking Claude to confirm with the user before running git commit
• Keep commit outside the allowed actions, or gate it with a hook that requires confirmation
• A PostToolUse hook on git commit that opens the diff for the developer to review
• Run the whole session in plan mode so no commands execute until the developer approves the plan

Which of these belongs in CLAUDE.md rather than a subagent or a skill?

• The linter command and a note that the tests need the local database running
• The API keys for the staging environment so tests can run end to end
• A 200-page design document describing every subsystem in the product and how they connect
• A weekly status report template the team fills in every Friday

You need Claude Code to review a pull request in CI and post comments, with no ability to push code. Which controls?

• Interactive mode on the runner so a reviewer can approve each tool call
• Print mode with full permissions, relying on the prompt to say 'do not push code'
• Print mode with a read-only tool allow list and the git push command denied
• Plan mode, since planning cannot push code and can still read the diff

A Claude Code session is asked to fix a bug and, without being asked, refactors three unrelated files. What reduces this?

• A larger context window so Claude can see why the other files are unrelated
• A PostToolUse hook that reverts any edit outside the file named in the prompt
• Running the fix headless so there is no room for exploratory editing
• Explicit scope in the prompt, CLAUDE.md conventions about minimal diffs, and plan mode for review

What is the purpose of a PreToolUse hook?

• Compact the context when a tool result is too large
• Inspect or block a tool call before it executes
• Run a command after the model has finished its response
• Swap the model for a cheaper one on routine tool calls

A system prompt says 'be helpful' and the outputs vary wildly in format. The highest-leverage change is:

• Adding 'be concise and consistent' to the system prompt
• Lowering the temperature so the formatting varies less
• Stating the exact output format with a short example
• Adding a persona so the model has a stable voice to write in

You need the model to reason through a multi-step pricing rule before answering. Which technique?

• Split the request across two turns, one for the rule and one for the answer
• Provide several unrelated worked examples so the model learns to be careful
• Ask for the final price only, with a rule that the answer must be a single number
• Ask it to work through the steps before answering, or enable extended thinking for the hard cases

Which is the best use of XML-style tags in a prompt?

• Separating instructions, reference documents, and examples so the model does not confuse them
• Signalling to the API which sections of the prompt are eligible for prompt caching
• Marking the parts of the prompt the model may skip when the context is nearly full
• Replacing the system prompt with a tagged block at the top of the user turn

You want responses to begin with a JSON object and nothing else. Which technique reduces preamble?

• Adding 'respond with JSON only' as the last line of the system prompt
• Prefilling the assistant turn with the opening brace
• Setting stop_sequences to a closing brace so the model ends at the object
• Setting temperature to zero so the model picks the most likely opening

The model keeps inventing a citation when a source is missing. Which instruction helps most?

• 'Keep answers short so there is less room for unsupported claims to appear'
• 'If no source in the provided material supports the claim, say so instead of citing'
• 'Cite at least one source for every claim, using the provided material where possible'
• 'Use your own knowledge to fill gaps when the provided material does not cover a claim'

Which examples make few-shot prompting work best?

• A few examples that closely match the target task and format, including a tricky edge case
• Examples drawn from a different but similar domain to avoid overfitting to the test set
• Examples that deliberately contain errors, with corrections, so the model learns what to avoid
• A large set of loosely related examples so the model sees the range of possible inputs

A prompt for summarizing meeting notes should also flag decisions and owners. Where do those requirements go?

• Stated explicitly as required output sections, with an example
• Implicitly, since a well-written summary includes decisions and owners
• In the system prompt as a general instruction to 'capture action items'
• In a second call after the summary, so each call has one job

What is the role of the system prompt compared with the user turn?

• The system prompt is where the model name and version are declared; the user turn holds everything else in the request
• The system prompt sets standing role, rules, and format; the user turn carries the specific task and material
• The system prompt carries the material to analyze; the user turn carries the standing rules
• They are interchangeable; the model concatenates them before reading either

A prompt includes ten rules and the model follows nine. Which change is most effective?

• Move the missed rule near the task, restate it as a concrete check, and add an example of compliance
• Delete the nine rules that already work, so the missed one gets the model's full attention
• Move the missed rule into a tool description so the model reads it when it acts
• Repeat the missed rule in capitals at the top and bottom of the system prompt

When should you ask the model to quote the relevant passage before answering a question about a long document?

• Only when streaming, since the quote arrives first and gives the user something to read while the answer generates
• When the answer is a single fact, since longer answers already cite their sources
• When accuracy on the document matters, since grounding in quotes reduces invented details
• Only for documents short enough that the quotes do not add much to the output

A prompt asks for 'a short answer' and gets three paragraphs. What fixes it reliably?

• Reduce temperature to zero so the model chooses the most likely, usually shorter, phrasing
• Specify the length in sentences or words and show an example of the right length
• Set max_tokens to a small value so the response cannot run to three paragraphs
• Add 'be brief' to both the system prompt and the user message

Which is a sign that a task needs extended thinking rather than a normal response?

• The prompt is long and contains several reference documents the model has to read through
• The task requires weighing several constraints and checking intermediate steps
• The user wants the answer quickly and is willing to accept a rough result
• The output must follow a strict schema that downstream code will parse

What is a good way to make a prompt testable?

• Test it against live traffic and roll back when the error rate rises
• Define expected outputs for a set of inputs and check the prompt against them after every change
• Freeze the prompt once it works and route changes through a new prompt
• Keep the prompt general so it holds up on inputs you did not anticipate

Which change most often improves a prompt that is 'almost right'?

• Adding a persona that matches the domain the prompt operates in
• Adding a line asking the model to double-check its answer before responding
• Moving the instructions from the system prompt into the user turn
• Replacing an ambiguous instruction with a specific, checkable one

Two tools, search_customers and find_customers, do nearly the same thing and the model picks inconsistently. What should you do?

• Add a routing instruction to the system prompt that says which tool to prefer
• Merge them into one well-described tool, or make their purposes clearly distinct in name and description
• Set tool_choice to the preferred tool so the model no longer has to choose
• Keep both and add a third tool that wraps them and picks the right one internally

A tool returns a 4 MB JSON dump on every call and the agent's context fills quickly. Best fix?

• Ask the model to summarize each result before continuing so the raw dump is dropped
• Return only the fields the task needs, paginate, and let the model request more
• Call the tool less often by caching its output in the system prompt for the session
• Compress the JSON before returning it so it occupies fewer tokens in context

Which naming convention helps a model with many tools?

• Consistent namespacing by system, such as crm_search and crm_update
• Short names of one or two characters so the tool list stays compact
• Names that describe the return type, such as list_result and single_result
• Names that include the version, such as search_v2, so the model picks the latest

An MCP server exposes a 'prompts' primitive. What is it for?

• Reusable prompt templates the client can discover and invoke
• The configuration block that tells the client how to authenticate and transport
• Instructions the server injects into the client's system prompt on connect
• The templates a tool uses to format its own results before returning them

A remote MCP server holds customer data. Which is required?

• Restricting the server to read-only tools so a compromised client cannot change data
• Storing an API key in the tool description so the model can present it on each call
• Running the server over stdio through an SSH tunnel so that no HTTP endpoint is ever exposed to the network
• Authentication and authorization on the server, with the client presenting credentials

What should a tool's description include beyond what it does?

• When to use it and when not to, parameter meanings, and edge cases
• The list of other tools that must be called before it, so ordering is explicit
• The expected latency and rate limits so the model can plan parallel calls
• The server it lives on and the endpoint it calls, so the model can troubleshoot failures

A tool has a 'delete' action and a 'read' action behind one parameter. Why is that a design problem?

• Enum parameters are poorly supported in JSON Schema, so the model will often pass an invalid value
• The model will default to the first enum value, so reads will be attempted as deletes
• One parameter cannot carry two verbs, so the schema will fail validation on the API
• Read-only and destructive actions need different gating; split them so the destructive one can be permissioned separately

The model calls a tool with a date in the wrong format, repeatedly. Best fix?

• Remove the date parameter and have the tool default to today, asking the user for other dates
• Add a schema format hint and an example value in the description, and return a clear error on bad input
• Add a system prompt rule stating the date format, since the model reads the tool description less carefully
• Accept any format the model sends and normalize it inside the tool, so the loop never stalls

When is parallel tool use appropriate?

• When latency matters, regardless of whether one call's input comes from another
• When the model is confident about all the arguments before the first result returns
• When the calls are independent and the results do not depend on one another
• When the tools belong to the same MCP server, so one connection can batch them

Which is a resource in MCP terms?

• The transport the client uses to reach the server, such as stdio or streamable HTTP
• Data the client can read, like a file or a record, addressed by URI
• A function the model can call to change state on the server
• A reusable template the user selects to start a conversation

A tool should be idempotent when:

• It only reads data, since reads are the calls the loop repeats most
• Its effects must be safe to repeat, because agent loops retry
• It has no parameters, so every call is identical by construction
• It runs over stdio, where a dropped connection replays the call

What is the safest default for a new tool that writes to an external system?

• Disabled in production and enabled only in a staging environment until accuracy is measured
• Autonomous use for small writes and confirmation for large ones, with the threshold set by the model
• Requires confirmation until its accuracy is measured
• Autonomous use with a nightly report of what it wrote, so problems surface within a day

What is 'context rot'?

• A caching bug in which a stale cached prefix is served after the system prompt has changed
• The gradual loss of tool results when compaction summarizes older turns
• The decline in response quality as the window fills with stale or irrelevant content
• The drift in a model's behavior over weeks as the provider updates it

An agent needs occasional access to a 500-page manual. Best approach?

• Load the whole manual into every prompt and rely on prompt caching to keep it cheap
• Summarize it once into a few pages and give the agent only the summary
• Index it and retrieve relevant sections on demand, giving the model identifiers it can fetch
• Split it into ten chunks and run a subagent per chunk on every question

Which content should sit at the start of the prompt for prompt caching to help?

• The conversation history, since it is the largest part of the request
• The user's latest question, so the model reads it before the long material
• The stable system prompt and tool definitions
• The most recent tool results, since those are reused across turns

A long-running agent needs to remember decisions across sessions. Which mechanism fits?

• A longer system prompt that lists the decisions made so far
• A larger max_tokens value so the agent can restate all of its decisions in each response
• Prompt caching on the previous session's transcript so it is cheap to include
• A memory file or structured notes the agent reads at start and updates as it works

Why hand a subagent a task instead of doing everything in one context?

• The subagent's working context stays separate and only its conclusion returns, preserving the main window
• Subagents can call tools the main session is not allowed to use
• Subagents run on a different model, so the main session's model stays available
• Subagents share the main session's context, so they start with full knowledge of the task

A prompt includes the full history of a two-hour support chat. Most of it is resolved. What should you do?

• Summarize the resolved parts and keep the open issue verbatim
• Keep the last twenty messages and drop everything before them
• Drop the history and restate the open issue in a fresh prompt
• Keep the full history, since the model may need context from resolved issues

Which is a symptom that a context window is being wasted?

• Responses that arrive faster than the previous session's
• Frequent cache hits on the system prompt across many consecutive requests from the same client
• Large tool results the model never uses and repeated boilerplate in every turn
• Short prompts that leave most of the window empty

What is the trade-off of aggressive summarization in an agent loop?

• Summaries make later turns slower because the model must reconstruct the details
• Headroom and speed at the cost of detail, so keep exact values and identifiers later steps need
• Summaries break tool use because tool_result blocks cannot be summarized
• Summaries are safe as long as the summary is written by a larger model

Which information should be kept verbatim through compaction?

• The earliest turns, since they set up the task
• Resolved errors and their stack traces, in case they recur
• Identifiers, exact values, and the current task definition
• The greetings and pleasantries, since tone carries across turns

A team wants to cut cost on a chat product with a long, stable system prompt and many short user turns. First lever?

• Prompt caching on the system prompt and tool definitions
• Batching user turns so several are answered in one request
• Switching to a smaller model for every turn after the first
• Trimming the system prompt to a few lines so every request is smaller

What does 'give the agent lightweight identifiers' mean in context engineering?

• Pass file paths, record ids, and URLs so the agent can fetch details when needed instead of front-loading everything
• Replace user names with anonymous ids before content reaches the model
• Use short variable and file names in the code the agent works on so tokens are saved
• Give each tool a short alias so the tool list occupies fewer tokens

How should an architect decide the context budget for a step in a workflow?

• From what the step must read and produce, leaving headroom for tool results and reasoning
• Split the total window evenly across the steps in the workflow
• Reuse the budget from the last project that used the same model
• Use the model's maximum on every step so no step runs out of room

A due-diligence agent must read 300 contracts and produce one risk table. Which structure keeps quality consistent?

• Load all 300 contracts into one long context and ask for a single risk table in one pass
• Fan out one worker per contract with the same extraction brief and schema, then merge the structured results
• Route each contract by type to a specialist prompt and let each specialist write its own section of the table
• Chain the contracts sequentially so each worker sees the previous worker's risk rows before extracting its own

What is the main cost of adding a 'reflection' step where the agent critiques its own output before returning it?

• Added tokens and latency, so it pays off where errors are expensive and the criteria are checkable
• It blocks tool use during the critique turn, so agents that rely on tools cannot use reflection safely
• It only works with a larger model as the critic, which doubles the cost of every task in the pipeline
• The critique tends to anchor on the draft, so it should replace the generator rather than follow it

An agent is allowed to call a payments API. Which control is non-negotiable?

• An evaluator model that reviews each proposed payment call and rejects any that look unusual
• An enforced gate outside the model that requires approval or applies limits before the call executes
• A system prompt instruction to confirm the amount with the user before every payment call
• A detailed tool description that lists the payment limits so the model knows when to refuse a transfer

Which sign suggests a workflow should be split into two chained model calls?

• The task takes several seconds per run, and latency matters more than accuracy for this use case
• The prompt calls a single tool several times per run, and each call returns a large result
• One prompt both extracts facts and writes persuasive prose, and one of those two keeps degrading
• Outputs are short and consistent, but the prompt is longer than the team would like to maintain

A team runs an agent that reads email and drafts replies. A client asks why it never sends automatically. Best answer?

• Autonomous sending would break prompt caching because each sent message changes the conversation prefix
• The Messages API has no outbound email capability of its own, so a person has to press send in the mail client each time
• Sending is irreversible and public, so it stays gated by a person until measured accuracy earns more autonomy
• The agent runs in a workflow rather than an agent loop, and workflows cannot trigger external actions

What distinguishes routing from an orchestrator in the workflow patterns?

• Routing requires a separate model per path, while an orchestrator uses one model for every subtask
• Routing sends an input down one of several fixed paths; an orchestrator plans dynamic subtasks and synthesizes results
• Routing runs several fixed paths in parallel and merges their outputs; an orchestrator runs the same paths one after another and keeps the best
• Routing is a form of parallelization; an orchestrator is a form of evaluator-optimizer loop

An agent produced a correct answer but took 40 tool calls where 5 would do. Which lever addresses this?

• Sharper tool descriptions, an explicit plan step, and a per-task call budget with feedback as it nears the limit
• Cut the tool list down to the two or three tools the task used most, so there is less to choose from and fewer wrong turns
• Switch to parallel tool calls so the 40 calls complete in the time five sequential ones would take
• Lower the context window by trimming the system prompt so the model has less to reason over each turn

Why should a subagent's brief include the success criteria and the expected return format?

• So the coordinator can reuse the subagent's full transcript as context for later steps instead of a lossy summary
• So the subagent knows when to stop and the coordinator can merge results without re-reading transcripts
• So the subagent can skip tool calls and answer from the brief alone, saving tokens
• Because the Agent SDK rejects a subagent definition that has no output schema attached

A stakeholder asks for 'an AI that runs the whole department'. As the architect, the first design move is:

• Build one general agent with every department tool attached and let it learn the workflows from use
• Start with an orchestrator-workers system so each function of the department gets its own dedicated worker agent
• Map the workflows, classify steps by predictability and blast radius, and start with the predictable ones
• Pick the most capable model available so the agent can handle whatever the department throws at it

Which is the correct role of an evaluator in an evaluator-optimizer loop?

• Produce the first draft, then revise it against the same criteria in a single turn
• Decide which tools the generator may call on its next attempt at the task
• Summarize the generator's transcript so the loop fits in the context window
• Judge the draft against explicit criteria and return specific, actionable feedback

An agent needs to process items that arrive continuously over a day. What design fits?

• A single batch prompt at the end of the day that processes all items together in one call
• One long-running session that keeps every item in context so it can spot patterns across the day
• A queue-driven loop that handles each item in a fresh bounded context and persists state between items
• An orchestrator that spawns a subagent per item and keeps every subagent transcript for the coordinator

What is the practical reason to make agent steps observable with structured logs rather than free-text notes?

• Structured logs can be queried, rolled into metrics, and replayed for evaluation
• The model produces more consistent reasoning when it is asked to log in a structured format
• Free-text notes consume more tokens per step, so structured logs keep the run inside the context budget
• Structured logs are required for prompt caching to work across steps of the run

A coordinator receives conflicting answers from two subagents. Sound handling?

• Take the answer from whichever subagent used more tool calls, since it did more research
• Merge both answers into one combined response and let the downstream consumer decide which parts to trust
• Detect the conflict, resolve it with a defined rule or a verification step, and record the decision
• Rerun both subagents with the same brief and accept the answer that appears more often

Which situation calls for human-in-the-loop by design rather than by exception?

• Any step where the model reports low confidence in its own answer partway through the run
• Approving legal commitments, spending above a threshold, or changes to people's records
• Steps where two workers in a parallel fan-out return different formatting
• Every tool call that reads from a production database rather than a staging copy

What is the risk of letting an agent modify its own instructions during a run?

• The run costs more because each instruction rewrite invalidates the cached prompt prefix
• There is little risk if every instruction change is logged, since the log lets you replay the run afterward
• Drift and loss of control; standing instructions should be fixed, versioned, and changed by people
• The agent becomes slower to complete tasks because it spends turns editing its own prompt

A workflow's third step frequently fails on malformed input from step two. Best fix?

• Validate step two's output against a schema before step three runs, with a repair path on failure
• Merge steps two and three into one prompt so there is no boundary for malformed data to cross
• Wrap step three in a retry loop with backoff so transient formatting problems resolve themselves
• Ask step three to tolerate malformed input by instructing it to do its best with whatever arrives

A monorepo has several services with different test commands. Where should that live for Claude Code?

• A subagent per service that carries that service's commands in its own prompt
• The first message of each session, restated whenever the service changes
• CLAUDE.md, with a short per-service map of test commands and conventions
• The repository README, which Claude Code reads automatically at session start

Which hook event would you use to run a security scan on every file Claude writes?

• A slash command the developer runs after each session to scan changed files
• A PreToolUse hook on the Read tool, so files are scanned before Claude opens them
• A PostToolUse hook matched to the Write and Edit tools, run after each change lands
• A Stop hook that scans the whole working tree once when Claude finishes its turn and reports findings

A developer wants Claude Code to ask before running any command that touches the network. Which setting?

• Permission rules that allow safe commands and require confirmation for matching network commands
• A CLAUDE.md instruction telling Claude to ask for confirmation before any command that reaches the network
• A PostToolUse hook on Bash that inspects the command for network calls and logs a warning
• Plan mode for the whole session, so every command is proposed before it is executed

What is the benefit of committing project-scoped MCP configuration to the repo?

• It lets the repo's MCP servers override the user's own server settings for the project
• Every contributor gets the same integrations without manual setup on each machine
• Claude Code caches the server tool lists in git, which speeds up session start
• Server credentials travel with the code, so contributors do not need their own tokens

Claude Code proposes a plan that touches an unrelated module. What is the right response in plan mode?

• Accept the plan, then revert the unrelated edits during code review
• Revise the plan's scope before any edits are made to the tree
• Run the test suite first to see whether the extra module is affected
• Exit plan mode and let Claude discover the right scope as it edits

Which is a sensible use of a Claude Code skill?

• A packaged procedure like 'write a release note from merged PRs' with its own instructions and helper files
• A per-task override that switches the session to a different model for that procedure
• A place to store the API keys and tokens the procedure needs, loaded only when invoked
• A replacement for CLAUDE.md that holds all project conventions and commands in a single file loaded on demand

You want a nightly job where Claude Code triages new issues and labels them. Which pieces?

• Print mode in a scheduled job with a read-only tool set plus one allowed labeling action
• A PostToolUse hook that fires whenever a new issue is created and labels it in place
• A subagent with full permissions, invoked from a cron entry with the issue list as input
• An interactive session left open overnight with auto-accept enabled for all tool calls

A PreToolUse hook exits with code 2 on a tool call. What should happen?

• Claude Code ends the session so the developer can inspect the hook's output manually
• The call is blocked and the hook's message is surfaced so the model can adjust
• The hook is disabled for the rest of the session and the call is retried once
• The call proceeds and the hook's stderr is shown to the user, as with other non-zero exits

Which practice keeps a long Claude Code session productive?

• Pasting the previous session's transcript at the start so no earlier decision is lost
• Keeping one session open so the model keeps every file it has read
• Clearing or compacting between unrelated tasks and re-briefing the next task
• Disabling hooks mid-session so tool calls complete with less overhead

What should a team review when a Claude Code change is opened as a pull request?

• The test output only, because a green suite proves the change is correct
• The diff, the tests it ran, and whether the scope matched the request
• Whether the CLAUDE.md conventions were followed, with the diff left to CI
• The commit message and the model version, since the diff itself was generated

Which is the right place for a rule like 'never edit files under vendor/'?

• A README section, since Claude Code reads project documentation before it edits
• CLAUDE.md for guidance plus a hook or permission deny rule for enforcement
• A comment at the top of each vendored file saying the file is not to be edited
• A dedicated subagent that owns vendor/ and rejects edit requests from the main session

How do subagents help with a large migration in Claude Code?

• They share the main session's context, so every slice sees the same file history and the same earlier decisions
• They run without tools, so they can plan slices while the main session performs the edits
• They bypass the test suite for each slice so the migration completes faster
• Each handles a bounded slice in its own context and returns a summary, keeping the main session coherent

Which instruction most improves factual grounding when documents are provided?

• 'You are a careful analyst who values accuracy above all else in every answer you give'
• 'Be concise and accurate, and avoid speculation unless the user asks for it'
• 'Combine the documents with your own knowledge and give the most complete answer'
• 'Answer only from the provided documents and cite the passage; if it is not there, say so'

A prompt must produce output in a strict template across thousands of runs. Which combination is strongest?

• A detailed persona plus a high temperature so the model stays engaged across runs
• Ten varied examples with no explicit template, so the model infers the pattern
• A precise template, one or two examples, and schema enforcement where possible
• A long narrative description of the task that explains why the template matters

What is the drawback of stuffing every possible rule into one system prompt?

• The model treats later rules as higher priority, so the early rules get ignored
• Rules compete and get missed; prioritize, structure, and test which ones matter
• Longer system prompts break prompt caching, so each run pays full price for the rules
• There is no real drawback as long as the rules are numbered and grouped by topic

When should you show the model a negative example (what not to do)?

• When a specific failure keeps recurring and a positive example alone has not fixed it
• Only as a last resort after temperature and max_tokens adjustments have both failed to help
• In every prompt, paired with each positive example so the contrast is explicit
• Only in the system prompt, since negatives in the user turn are treated as content

Which is the best way to get the model to ask a clarifying question instead of guessing?

• Include examples of confident guesses marked as wrong so the model learns to avoid them in similar cases
• Add a persona of a cautious consultant who checks with the client before acting
• Instruct it to ask when a required detail is missing, and define what counts as required
• Lower the temperature so the model is less willing to commit to an uncertain answer

A summarization prompt is losing important numbers. What helps?

• Ask for a shorter summary so the model focuses on only the most important facts
• Instruct it to preserve all figures, dates, and names verbatim, with an example
• Increase max_tokens so the summary has room for every number in the source
• Switch to bullet points, since lists make omitted figures easier for a reader to spot

What does 'role prompting' do well and what does it not fix?

• It sets tone and perspective; it does not fix missing instructions, data, or ambiguous tasks
• It fixes ambiguous tasks by giving the model a viewpoint from which to resolve them
• It replaces the need for examples, since a strong persona implies the expected output
• It improves factual accuracy by activating domain expertise the model would not otherwise use

Which prompt is more testable?

• 'Write a summary of at most 120 words with one sentence per section, listing every decision and owner'
• 'Summarize this document in the style of our best analyst, keeping the reader's needs in mind'
• 'Write a thorough, well-organized summary that a busy executive would find genuinely useful and complete'
• 'Produce a high-quality summary and double-check it for completeness before you answer'

You want the model to output only 'APPROVE' or 'REJECT'. What is the most reliable approach?

• Constrain the output through an enum in a tool schema, or prefill and instruct with examples
• Add a strict reviewer persona and ask the model to be decisive in every answer it gives
• Raise max_tokens and instruct the model to end its response with the final label on its own line
• Ask the question twice and accept the label only when both responses agree with each other

How should a prompt handle ambiguous user requests in a customer-facing product?

• Instruct the model to answer every plausible interpretation in turn so the user can pick the right one
• Instruct the model to state its interpretation or ask one clarifying question, per product policy
• Instruct the model to choose the most common interpretation and answer with confidence
• Instruct the model to decline ambiguous requests and direct the user to a support form

Which change is likely to reduce hallucinated tool parameters?

• Fewer examples in the tool description, so the model relies on the schema alone
• A system prompt persona of a careful engineer who double-checks every parameter before calling a tool
• Examples of correct calls in the tool description and a schema with enums and required fields
• Longer output budgets so the model has room to reason before it commits to a call

What is a reasonable way to iterate on a prompt with a team?

• Freeze the prompt after launch and route new requirements to a separate prompt
• Versioned prompts, a shared eval set, and review of score changes before deploy
• Each teammate tests edits in their own environment and merges whichever version feels best
• One owner edits the production prompt by feel and watches user feedback for regressions

A tool takes 20 optional parameters and the model rarely sets them correctly. Best redesign?

• Move the parameter guidance into the system prompt so it is not lost in the schema
• Keep the tool but add a validation step that rejects calls with unset parameters
• Make every parameter required so the model has to think about each one explicitly
• Split into focused tools with few required parameters and sensible defaults

What should a search tool return to be most useful to an agent?

• The raw response from the underlying search service, unmodified
• A count of matches with a suggestion to narrow the query whenever the count is above a threshold
• Every matching record in full, so the agent never needs a second call
• A compact ranked list with identifiers and snippets, plus a way to fetch details

Which MCP capability lets a server suggest a full workflow prompt to the client?

• Resources, which expose text or data the client can load into context by URI when it needs it
• Sampling, which lets the server request a completion from the client's model
• Prompts, which are reusable templates the client can present for the user to invoke
• Tools, which return a suggested plan the client then executes step by step

A tool's description says 'Use this for anything related to customers'. Why is that weak?

• It is too broad: it invites misuse and overlaps with other tools; describe the job and when not to use it
• It is phrased as an instruction to the model, when descriptions should be neutral statements of what the tool does and returns
• It fails to list the parameter types, so the model cannot construct a valid call
• It is too short; a description should run to several paragraphs to cover every case

When should a tool return an error rather than a best-effort result?

• Only when the model has asked for strict mode; otherwise return a best-effort result silently
• When the input is invalid or the operation cannot complete correctly, with a message saying what would fix it
• Only on timeouts and network failures; for bad input, return the closest valid result with a note explaining the substitution
• Whenever the operation partially succeeds, so the model retries the whole call from scratch

Which is true of tool_result blocks?

• They replace the assistant's tool_use block in the conversation history
• They are returned in a user turn, matched to the tool_use block's id
• They are placed in the system prompt so the model sees them on every later turn
• They must contain valid JSON so the model can parse them reliably

How do you keep an MCP server safe when it exposes both read and write operations?

• Trust the model's judgment on each call but log every write so problems can be traced and reversed afterward
• Separate read and write tools, require authentication, and gate writes with confirmation or scopes
• Combine reads and writes in one tool with a mode flag so the model sees fewer tools
• Expose write operations only over stdio, since local transport limits who can call them

A model keeps calling a tool that is not relevant to the task. Which fix comes first?

• Delete the tool from the set, since a tool that gets misused is a net cost
• Lower the temperature so the model becomes more conservative about tool selection
• Add a system prompt rule that lists the exact tasks the tool may be used for and the tasks it may not
• Tighten its description with 'when not to use' guidance and check for overlap with other tools

Why include units and formats in parameter descriptions?

• They let the model skip the schema and construct calls from the description alone
• So the model supplies values the tool can parse, avoiding silent errors
• They are mainly for the humans who review tool calls in the logs
• The MCP specification requires units in every numeric parameter description

What is a good reason to expose a resource instead of a tool?

• The data is read-only reference material the client can load on demand by URI
• Loading the data has side effects that should be visible in the audit log
• Access to the data requires a human approval step before it is released
• The data changes every second and the client needs the freshest possible copy

A prompt is 150k tokens and quality is uneven. What is the first question to ask?

• Whether a newer model with a larger context window would handle the same 150k tokens more evenly
• Whether raising max_tokens would give the model more room to work through the material
• How much of that context the task needs, and whether retrieval or summarization could replace the bulk
• Whether the prompt has a clear persona so the model knows how to weigh the material

What goes in a memory file that an agent maintains across sessions?

• Every tool result, so the agent can avoid repeating calls it already made
• Decisions, open items, and pointers to sources, kept short and current
• Full transcripts of each session so nothing is lost between runs
• Credentials and endpoints the agent needs, so it can start without setup

Which practice supports prompt caching across many users of the same app?

• Randomize the order of instructions so no single prefix dominates the cache
• Disable the system prompt and pass all instructions in the first user message
• Put each user's profile at the start of the system prompt so it is cached per user
• A shared stable prefix, with user-specific content after the cache breakpoint

How should long tool outputs be handled in an agent loop?

• Kept in full, since dropping any part of a tool result risks losing something the task needs
• Moved into the system prompt so they are cached and do not consume the conversation budget
• Deleted after the turn that used them, since the model has already acted on them
• Truncated or summarized to the essentials, keeping identifiers so details can be re-fetched

What is a reasonable trigger for compaction in a long session?

• Approaching the context budget or finishing a subtask
• Only when a tool call fails, since errors usually mean the context is polluted
• Only when the user asks, since the model cannot judge when to compact
• After every message, so the window stays as small as possible

Why can a smaller, curated context beat a larger one?

• Less irrelevant material means better attention to what matters, alongside lower cost
• The claim does not hold; more context is better as long as it fits inside the model's window
• Models are trained on short prompts, so long prompts fall outside the distribution
• Smaller contexts are cheaper, and the cost saving is the only real difference

An agent must reference a style guide on every task. Where does it belong?

• Pasted into each user message so it is always the most recent input
• Summarized to one line in the system prompt to save tokens
• In the stable prefix so it caches, or loaded once per session
• Returned through a tool result on the first turn of each task

What should be true of the summary you carry forward after compaction?

• It is as short as possible, ideally one sentence describing the goal
• It keeps the full tool results, since those are the hardest to reconstruct
• It restates the system prompt so the instructions survive the reset
• It preserves task definition, decisions, exact values, and next steps

Which is a symptom of context overflow rather than a bad prompt?

• The model asks for information that was never provided in the conversation
• Late-conversation instructions ignored and earlier details contradicted
• Answers that are shorter than usual and skip the requested formatting
• Slower responses and higher cost per turn as the conversation grows

How do subagents relate to context budgets?

• They share the coordinator's budget, so each subagent reduces what is left for the rest
• Each has its own budget, so heavy subtasks do not consume the coordinator's window
• They have no budget of their own and rely on the coordinator to compact for them
• They double the coordinator's window, since each subagent adds its own context to it

A nightly job classifies 50,000 support tickets into one of eight categories. Which architecture is right?

• One agent with the full ticket export in context so it can spot category patterns
• An autonomous agent per ticket with tools to look up the customer's history before deciding
• An orchestrator that spawns one classifier subagent per category and lets them vote on each ticket
• A batch workflow with a fixed prompt and schema-constrained output, plus a sampled human audit

Which question best decides whether a task needs an agent at all?

• Can the steps be written down in advance, or does the path depend on what the model finds along the way?
• Is the budget large enough to absorb the extra tokens that an agent loop consumes?
• Does the task involve tools, since tool use is what distinguishes an agent from a prompt?
• Is the model capable enough to complete the task end to end without a human checking each intermediate step?

An agent's outputs are correct but users complain it 'never explains why'. What is the low-cost design fix?

• Enable extended thinking and return the thinking blocks to users as the explanation
• Ask for a brief rationale alongside the structured result, kept separate from the machine-readable fields
• Add a second model call that reads the result and writes an explanation for the user
• Drop the structured output and return prose so the reasoning and the answer arrive together in one readable block

Two subagents produce partial reports and the coordinator must merge them into one document. What protects merge quality?

• A fixed output schema for the partials so merging is deterministic, then one editing pass for coherence
• Run the two subagents sequentially so the second one extends the first one's document
• Let the coordinator read both partials in full and improvise a merged document
• Have each subagent read the other's draft before finishing so the two partials already agree on structure and content

Which is the right response when an agent's evaluator step disagrees with a human reviewer 30% of the time?

• Average the evaluator's score with the human's so neither judgment dominates the outcome
• Trust the evaluator, since consistent model judgments beat a single reviewer's opinion
• Calibrate the evaluator against the human labels, refine its criteria, and keep the human until agreement is high
• Replace the evaluator with a second human reviewer, since a 30% disagreement rate shows model grading does not work here

A client wants the agent to run overnight unattended. Which capability must exist first?

• Extended thinking on every turn so the agent reasons carefully without supervision
• A hard stop on cost and turns plus alerting, so an unattended run cannot spiral
• A dashboard showing live progress so the team can check on it in the morning
• A larger model, so the run makes fewer mistakes when nobody is there to correct it

What does 'fail closed' mean for an agent that hits an unexpected error?

• Stop the action, record the state, and hand off to a person or a defined fallback
• Retry the failing step with a different tool until one of them succeeds
• Continue with the most likely interpretation and flag the guess in the final report
• Restart the whole task from the beginning with a fresh context and the same inputs

An orchestrator-workers design is producing repeated work across workers. Likely cause?

• Too few workers, so each one is covering more of the task than it can hold in context
• Overlapping subtask briefs; the coordinator should partition the task so each worker's scope is disjoint
• Missing evaluator step, so duplicate outputs are never caught before the merge
• The workers share one context window, so each one sees the others' progress and repeats it in its own output

Which metric would you add to detect that an agent is 'succeeding' by giving up early?

• Task completion checked against explicit acceptance criteria, not the model reporting done
• Tool calls per task, since an agent that stops early makes fewer calls than expected
• Latency per task, since early exits finish faster than runs that do the whole job
• Average tokens per task, since a run that gives up early uses noticeably fewer tokens than a full run

A workflow needs a human to approve step three only when the amount exceeds a threshold. How do you model it?

• Instruct the model to decide when the amount seems high enough to ask a person
• Require approval on every run of step three, since a threshold check adds complexity
• A conditional gate in the workflow that routes to a human queue when the condition holds
• Have an evaluator model review step three's output and escalate whenever the amount looks risky

Which practice keeps agent behavior reproducible enough to debug?

• Logging the exact prompts, tool inputs and outputs, and model settings per step
• Using the largest model, since stronger models behave more predictably
• Turning off prompt caching so each step is computed fresh from the raw prompt
• Setting temperature to zero, which makes each run identical for the same input and settings

A stakeholder asks why the agent needs a 'planning' step that costs extra tokens. Best answer?

• It makes the model look more deliberate, which builds stakeholder confidence in the output even when the plan is not followed
• The Agent SDK requires a planning turn before any tool call can be executed in a session
• Plans are cached as part of the prompt prefix, so every later turn in the same run costs less per token than the first
• On multi-step tasks a plan cuts wasted tool calls and lets people review intent before actions, usually saving more than it costs

A team wants Claude Code to follow its commit message convention every time. Which approach is reliable?

• State the convention in CLAUDE.md with an example, and validate with a hook on commit
• Delegate all commits to a subagent whose prompt contains the convention
• Tell Claude Code once at the start of the session and rely on it for the rest of the work
• Let Claude Code infer the convention from the existing git log before it commits

Which is a good reason to use headless Claude Code inside a GitHub Action?

• Exploring an unfamiliar codebase, since the runner has a clean checkout to learn from
• Pair programming on a feature branch, with the Action re-running after every push
• Repeatable, reviewable automation such as summarizing a PR, with a fixed tool allow list
• Interactive debugging of a failing build, where the developer talks to Claude in the CI logs

A hook blocks a command but Claude Code keeps retrying variations. What is missing?

• A stricter permission rule that denies the Bash tool entirely for the session
• A longer CLAUDE.md section repeating the rule the hook is enforcing
• A clear block message that says what is disallowed and what to do instead
• A second hook on the Stop event that ends the turn after the first block

What is the difference between a slash command and a skill in practice?

• Slash commands need an MCP server behind them; skills run entirely from Markdown
• Skills run in a separate subagent context by default; slash commands run inside the main session with its full history
• Slash commands are built in; skills are only available through installed plugins
• A slash command is a reusable prompt you invoke; a skill packages a procedure with instructions and supporting files

Which permission stance fits a developer's laptop versus a shared CI runner?

• Allow everything in CI since nobody is there to answer prompts, and deny most on the laptop
• The same rules in both, so behavior is predictable regardless of where it runs
• Deny all writes in both and let a human apply the changes Claude proposes
• Interactive approvals on the laptop; a narrow pre-approved allow list with no prompts in CI

Claude Code keeps reading the same large log file into context on every task. Fix?

• A CLAUDE.md note to grep the log for specific patterns rather than reading it whole, or a tool that returns matches
• Increase the session's context budget so the full log fits without truncation each time
• Compact the session after each read so the earlier copies of the log leave the context before the next task starts
• Move the log's contents into the project CLAUDE.md so it is loaded once at startup and cached

Which statement about CLAUDE.md scope is correct?

• CLAUDE.md is read only from the home directory, so project rules go in settings.json
• Files can live at the project root and in subdirectories, applying to work in those areas
• One CLAUDE.md file per repository is allowed, and it must sit at the repository root
• Subdirectory CLAUDE.md files replace the root file entirely when Claude works in that area

What should a team do before letting Claude Code run database migrations in a shared environment?

• Ask Claude Code to review the migration SQL itself for mistakes before running it against the database
• Disable hooks for the migration step so nothing interrupts a long-running command
• Grant the Claude Code process admin rights so the migration cannot fail on permissions
• Gate the migration command behind approval, run it against a staging copy first, and log the run

A developer asks Claude Code to 'make the tests pass' and it edits the tests to always pass. What prevents this?

• Removing the test files from the working tree during the task so only the source files are editable by the model
• Explicit instructions that tests define behavior and must not be weakened, plus review of test diffs
• A longer timeout, so the model has time to fix the code rather than the tests
• Running in plan mode so the model proposes edits but never applies them

When is a subagent overkill?

• For parallel research across several independent parts of the codebase
• For a one-line lookup the main session can answer directly
• For a large investigation that would fill the main session with file contents
• For isolating a noisy tool's output away from the main conversation

Which is the most reliable way to keep a chatbot on topic?

• Lower the temperature so the model is less likely to wander from the topic
• State the allowed scope and the exact behavior for out-of-scope requests, with an example refusal
• Ask it in the system prompt to stay focused and professional throughout the conversation and avoid tangents
• Limit max_tokens so long off-topic answers are cut off before they finish

A prompt uses the word 'summarize' but the stakeholder wants an executive brief with decisions and risks. What is the fix?

• Keep 'summarize' but add 'good' and 'executive' as qualifiers to signal the audience
• Add a persona of a chief of staff so the model understands who the reader is
• Replace the vague verb with the required sections and length, plus an example brief
• Move to a larger model, since executive briefs need stronger reasoning than summaries

What is the purpose of asking the model to plan before it writes a long document?

• Faster generation, since the model writes prose more quickly from an outline
• A structure to check and steer before tokens are spent on prose
• A longer output, since the plan and the document are both returned
• Fewer examples needed, since the plan takes the place of a sample document

Which instruction helps most when the model must handle inputs in several languages?

• State the expected input languages and the required output language explicitly
• Tell the model it is multilingual and let it match whatever language the user writes in
• Instruct the model to translate everything to English internally before answering
• Provide one example conversation in each language the product supports

You need consistent scoring of essays on a 1 to 5 rubric. What makes the prompt reliable?

• Extended thinking so the model weighs each essay carefully before it commits to a score
• The rubric spelled out per score level with an example essay at two or three levels
• A one-line instruction to score from 1 to 5, with temperature set to zero
• A persona of a strict but fair teacher with twenty years of grading experience

The model returns Markdown when you need plain text for an SMS. Simplest fix?

• Instruct plain text with no formatting, show an example, and validate before sending
• Switch to a smaller model, since smaller models use less formatting by default
• Ask for the message twice and send whichever version contains fewer formatting characters
• Strip Markdown syntax in code after generation and accept the occasional artifact

Why keep examples in a prompt consistent in format with the required output?

• The API validates examples against the output schema and rejects mismatches
• Consistent examples let the model skip reasoning and copy the pattern directly
• The model imitates the examples; inconsistent examples produce inconsistent output
• Consistent examples compress better, which keeps the prompt within the cache limit

What should you do when a system prompt and a user message conflict?

• Rely on the default, since the system prompt is guaranteed to win any conflict
• Raise the temperature so the model can weigh the two instructions more flexibly
• Remove the system prompt and put all instructions in the user turn so nothing can conflict
• Design the system prompt to state precedence for the cases you care about, and test them

Which is a sign a prompt is over-specified?

• Cache hits fall because the system prompt changes with every rule added
• The model asks clarifying questions on inputs the rules already cover
• Consistent output on the eval set but higher cost per call than the team expected
• Long rule lists the model ignores while output quality drops on normal inputs

How do you test a prompt change without a full eval suite yet?

• Change the prompt, the model, and the temperature together so any improvement shows clearly
• Ship the change to a small share of users and watch the support queue for complaints
• Ask the model to compare the old and new prompt and say which one it prefers
• A small fixed set of representative inputs, including edge cases, compared before and after

A tool's parameters are named a, b, and c. Why does that hurt?

• The model cannot infer meaning, so it guesses; descriptive names and descriptions fix it
• It only matters if the tool has no description, since the description explains the parameters
• Single-letter names shrink the JSON payload, so this is a reasonable trade for speed
• The schema will fail validation because JSON Schema requires property names of three or more characters

Which tool response is best for a 'list orders' call that matched 5,000 orders?

• The first page with a total count and a cursor for more
• An error telling the model to narrow the query before retrying
• The total count only, with a note that details are available on request
• All 5,000 orders, so the model has everything it needs in one call

When should a tool call require confirmation in a Claude Code or Agent SDK setup?

• Only for reads from production systems, since reads can expose sensitive data
• When it writes, deletes, sends, or spends, until its accuracy is proven
• For every call, since the cost of asking is small compared with any wrong action
• Only when the model reports low confidence in the parameters it chose

What is the practical difference between exposing data as an MCP resource versus returning it from a tool call?

• Resources are for structured data and tools are for text, so the choice follows the payload type
• Resources require user approval before the client loads them; tool calls are executed by the model directly without a prompt
• Resources are addressable read-only data the client loads when needed; tools perform actions and return results
• Resources are faster because the client caches them; tool results are fetched fresh every time

A remote MCP server should identify which agent is calling. Why?

• The stdio transport requires a caller id in every request frame
• The server selects which model to use based on the calling agent
• Identified callers get their tool lists cached, which speeds up discovery
• Authorization, rate limits, and audit depend on knowing the caller

An agent misuses a tool because its description was written for developers. What changes?

• Keep the developer description and add a system prompt section explaining to the model how and when to use the tool
• Move the developer notes into the parameter descriptions where the model reads them
• Rewrite it for the model: what it does, when to use it, when not to, parameter meanings, an example
• Add more parameters so the model has finer control over the tool's behavior

How should a tool report partial success, such as 8 of 10 records updated?

• Return success, since most of the records were updated and the model can move on
• Retry the failed records silently inside the tool and return success once they complete
• Return a structured result listing what succeeded and what failed, with reasons
• Return failure so the model retries the whole batch until every record succeeds

Which MCP transport suits a server that many users hit concurrently from a web app?

• Streamable HTTP, which supports remote, concurrent clients
• WebSocket only, since HTTP cannot carry the server's notifications
• A shared file system watched by the server for request files
• stdio, with one server process spawned per user session on the web host

Why keep tool schemas strict rather than accepting free-form strings?

• Strict schemas are optional in the API, so this is a style preference rather than a requirement
• Free-form strings are faster to generate, but strict schemas produce shorter code
• Free-form strings are rejected by the Messages API, so strict schemas are required
• Strict schemas let the model produce valid calls and let you validate before execution

An agent's context contains three copies of the same document from repeated tool calls. What is the fix?

• Tell the model in the system prompt to ignore repeated documents and use the first copy
• Increase the context window so the duplicates fit alongside the rest of the task
• Deduplicate tool results and cache the document by identifier so it loads once
• Add a compaction step after every tool call so older copies are summarized away

What is the value of a 'scratchpad' or notes file for a long task?

• It gives the model a place to write longer prompts for itself on the next turn
• It lets tools run faster because their results are written to disk instead of context
• Durable working memory outside the window, so progress survives compaction and restarts
• It replaces the need for compaction, since the window stops growing once notes are kept

Which order helps prompt caching for a multi-tenant assistant with shared instructions?

• Shared instructions and tools first, tenant data after the breakpoint
• Tenant data in the system prompt and shared instructions in the user turn
• Tenant data first so each tenant's cache is warm from the first token
• Alternate shared and tenant content so both are covered by the cache

A workflow step needs only two fields from a large upstream result. Best practice?

• Merge the step into the upstream one so no data has to be passed between them
• Pass the whole upstream result so the step has the full context available if it turns out to need more
• Extract the two fields and pass only those, keeping an identifier to fetch more if needed
• Summarize the upstream result in prose and pass the summary to the step

What does compaction risk if done carelessly?

• Slower responses, since the model must re-read the summary before it can act
• Dropping exact values, identifiers, or the current task definition that later steps need
• More tool calls, since the model re-fetches everything the summary mentions
• Cache misses on the next turn, since the compacted conversation prefix no longer matches the cached one

An agent must consult a policy document on every decision. Which approach balances cost and accuracy?

• Keep it in the cached prefix, or retrieve the relevant section per decision
• Paste the full document into each user turn so it is always the freshest input
• Summarize it once at session start and rely on the summary for every decision
• Load it through a tool call on each decision so it never occupies the prefix

Which is a symptom of too little context rather than too much?

• Responses slow down and cost per turn rises as the conversation grows longer
• Cache misses increase because the shared prompt prefix changes from one turn to the next as history grows
• The model asks for information it should have, or guesses at details that were never provided
• Instructions from early in the conversation are contradicted late in the conversation

How should you size retrieval chunks for a technical manual?

• As large as the context window allows, so each retrieved chunk carries the full surrounding material of the manual with it
• One sentence each, so retrieval can match the exact line the question is asking about
• Whole chapters, since a manual's own structure already groups the related material together and keeps procedures whole
• Large enough to hold one complete idea, like a procedure or section, and small enough to keep only relevant material in context

A coordinator agent's window is filling with subagent chatter. What is the structural fix?

• Have subagents return only structured results and keep their transcripts out of the coordinator
• Compact the coordinator's context after each subagent returns so the accumulated chatter is summarized away
• Disable logging in the subagents so their tool output is not echoed back
• Use fewer subagents so less of their output reaches the coordinator's window