• User inputs are essentially infinite and unpredictable — it's technically impossible to enumerate and test every possible combination.
• The exam guide (and general AI/agent engineering best practices) focuses on risk-based testing, not exhaustive input coverage.
• Aiming for 100% input coverage is a false goal that would consume unlimited time and resources without meaningfully improving reliability.

• Full coverage for structural issues
• Deep quality scoring without the cost of running LLM eval on everything
• Human judgment where it matters most

• Too slow to detect drift in real time
• Human-only evaluation doesn't scale to hundreds of contracts daily
• Weekly cadence means problems can go undetected for days

• Expensive and slow at 100% coverage
• LLM evaluating LLM output can have correlated blind spots — Claude may consistently miss the same errors
• Not sustainable as volume grows

• Only catches formatting/structural deviations
• Completely misses content quality, accuracy, and reasoning issues
• Too shallow for meaningful quality monitoring

• The system prompt is set by the operator (the developer/organization deploying Claude)
• The user is the end user interacting with Claude
• Operators have higher trust than users in Claude's hierarchy
• Therefore, system prompt instructions take precedence over conflicting user instructions

• Completely backwards. Users have less authority than operators by design. Operators set the rules for how Claude behaves in their product.

• Claude doesn't "split the difference." It follows the hierarchy. There's no blending mechanism — that would undermine the whole point of operator control.

• This is how a simple chatbot might work, but not Claude. Recency doesn't trump hierarchy. A user saying something last doesn't override what the operator established in the system prompt.

• It captures logging at the code level — reliable, consistent, and not dependent on Claude's behavior
• Records inputs, outputs, execution time, and errors automatically every single time
• Completely transparent to Claude — it doesn't change how the agent thinks or operates
• This is standard production observability practice (same pattern used with APIs, microservices, etc.)
• Works with the Agent SDK's architecture by sitting between the SDK and the tool execution

# Simple example of the pattern
def logging_decorator(tool_func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = tool_func(*args, **kwargs)
        log(tool=tool_func.__name__, inputs=args, 
            output=result, time=time.time()-start)
        return result
    return wrapper

• Prompting Claude to "log its tool calls" is unreliable — Claude might forget, skip, or format inconsistently
• Critical observability should never depend on model behavior alone
• Same principle as the earlier question: safety/reliability rules go in code, not prompts

• Debug mode is for development only — not suitable for production observability
• Typically too verbose, unstructured, and not customizable for business needs
• Not a real production logging strategy

• Relies on Claude remembering to call it after every operation — not guaranteed
• Adds unnecessary tool calls, increasing latency and cost
• Claude could skip it, call it inconsistently, or get distracted mid-task

• Claude can read and understand English system prompts and tool results
• Claude can detect the language of the user's message automatically
• Claude can generate a response in the customer's language (Japanese, Spanish, etc.) even though its internal context is in English
• No translation infrastructure needed — Claude handles this naturally

• Unnecessary complexity — Claude doesn't need the system prompt in the customer's language to respond in that language
• Translation of system prompts introduces risk of meaning drift or errors
• Multiplies maintenance burden (every system prompt change must be updated in N languages)

• Massive overhead and latency — translating every input/output through a separate tool
• Introduces another failure point in the pipeline
• Completely unnecessary given Claude's native multilingual ability

• Huge operational overhead — maintaining multiple agents for what Claude handles natively
• Scaling problem: what happens when you add a 4th or 5th language?
• Overkill solution to a non-problem

Don't engineer solutions for problems Claude already solves natively

content_block_start  (type: "thinking")  ? show typing indicator
    delta events...                       ? still thinking
content_block_stop                        ? thinking done ?
content_block_start  (type: "text")      ? switch to text display ?
    delta events...                       ? stream text to UI
content_block_stop                        ? response complete

• content_block_stop ending the thinking block ? hide typing indicator
• content_block_start with type "text" ? begin displaying streamed text

• This event does not exist in the Anthropic streaming API
• A made-up event — don't be fooled by plausible-sounding names in exam questions

• Also does not exist — message_delta carries token usage and stop reasons, not phase information
• Another fabricated field

• Completely false — everything happens over a single streaming connection
• Splitting connections would be architecturally bizarre and unnecessary

Content blocks are the fundamental unit of streaming structure in Claude's API

Phase 1 — Preview:
User/Claude calls scale_deployment(replicas=0)
Tool returns: {
  "preview": "This will scale deployment 'api-server' to 0 replicas, 
               causing downtime for all users",
  "confirmation_token": "abc123xyz",
  "expires_in": 60
}

Phase 2 — Execute:
Claude shows preview to user, user confirms
Tool called again with confirmation_token: "abc123xyz"
? Operation executes

• Confirmation is enforced at the code/tool level — not dependent on Claude's behavior
• The preview gives Claude and the user full understanding of consequences before acting
• The token ensures the exact same operation is confirmed (no bait-and-switch)
• Token expiry prevents stale confirmations from executing later
• This is a well-established pattern in infrastructure tooling (Terraform plan ? apply, kubectl dry-run ? apply)

• Relies entirely on Claude's behavior — not guaranteed or enforceable
• Claude might warn inconsistently or skip warnings under certain prompting
• Critical safety must live in code, not prompts (recurring principle)

• Adds access control but doesn't solve the confirmation problem
• An admin with credentials can still accidentally trigger dangerous operations
• Credentials ? confirmation of intent

• Better than A, but still weak — it's just a string check with no context
• Doesn't show the user what they're confirming (no preview)
• Can become muscle memory — users type CONFIRM without reading
• No token means no guarantee the confirmed action matches what executes

High-impact irreversible operations need enforcement at the tool level with a preview-before-execute pattern

Without caching:  60% of bill = input tokens
With caching:     60% × 10% = 6% of bill for same content

Savings = ~54% reduction in total API cost

• You're optimizing the smallest slice of the bill
• Even cutting output tokens by 50% only saves ~7.5% total
• Low leverage

• Better than A, but thinking tokens often directly affect output quality
• Cutting thinking to save cost can degrade the very results you're paying for
• Still less leverage than caching the 60%

• Reduces costs across all categories proportionally
• But sacrifices capability and quality — may not be acceptable for the use case
• Also doesn't exploit the specific insight that repeated context is the problem
• Blunt instrument vs. targeted fix

Always optimize the largest cost driver first, and use the tool designed specifically for that problem

.claude/
  rules/
    javascript.md   # applies to **/*.js, **/*.ts
    rust.md         # applies to **/*.rs

• Editing a .js file ? Prettier rules load automatically
• Editing a .rs file ? rustfmt rules load automatically
• No cross-contamination between language conventions

• Rules are context-activated — Claude gets exactly the relevant rules for the file it's editing
• Clean separation of concerns — each language's conventions live in their own file
• Scales easily — adding a 3rd language (Python, Go, etc.) is just adding another rules file
• No cognitive overhead — Claude isn't processing Rust rules while editing JavaScript

• Claude loads all rules for every file regardless of language
• Risk of confusion or mixing conventions when context switching
• Works but is less precise than glob-based targeting

• Only works if your project is strictly separated by directory
• Real projects often have mixed structures or shared directories
• Less flexible than glob patterns which match by file extension regardless of location

• Formatters handle auto-formatting but Claude still needs to know conventions when writing new code
• Without rules, Claude may generate code that passes logic but fails formatting checks
• Leaves Claude without guidance on style decisions formatters don't enforce

Glob-based rules give Claude precise, context-aware instructions — the right rules for the right files at the right time

{
  "metadata": {
    "source_agent": "agent_a",
    "message_id": "uuid-123",
    "timestamp": "2026-04-30T10:00:00Z",
    "version": "1.2",
    "domain": "financial_analysis"
  },
  "status": "completed",
  "data": {
    "result": "...",
    "confidence": 0.95
  }
}

• Structured format means agents can parse directly without extra tool calls — reducing latency and cost
• Clear metadata enables routing (Agent B and C only consume messages relevant to their domain)
• Versioning in metadata allows the system to evolve without breaking existing consumers
• Consistency means all agents speak the same language — no translation layer needed
• This mirrors real-world message bus design (Kafka, RabbitMQ, etc.) — proven patterns apply

• Plain text requires each agent to parse/interpret meaning from unstructured content — unreliable and expensive
• No standard structure means no reliable routing or versioning
• "Maximum compatibility" is a false benefit — structured formats like JSON are universally compatible

• Creates an N×N compatibility problem — every new agent needs custom format handling for every other agent
• Impossible to maintain at scale
• Defeats the entire purpose of a centralized message bus

• Same problem as C — no shared contract means chaos
• Agent A would need to know every consumer's preferred format and publish multiple versions
• Not scalable and tightly couples producers to consumers

In multi-agent systems, a shared structured message format with metadata for routing and versioning is the foundation of a maintainable, scalable architecture