25 Questions — Domain 3 : Claude Code

Expand any question to reveal the correct answer and explanation.

1. 1 A development team wants to ensure that specific architectural patterns are followed across a large monorepo when using Claude Code. Which configuration strategy provides the most granular control using glob patterns?

   Consider the method that allows for directory-specific logic rather than a single monolithic instruction file.

   Adding specialized rules files within the .claude/rules/ directory.

   The .claude/rules/ directory supports multiple files that can target specific paths and file types using glob patterns for modular instruction enforcement.

   • ✗ Defining instructions within a single root-level CLAUDE.md file.

     While effective for general project rules, a single file lacks the ability to apply different rules to specific sub-directories via globbing.

   • ✗ Configuring repository-wide behavior in the global ~/.claude/settings.json file.

     This file is typically used for environment-level settings like model pinning rather than repository-specific architectural rules.

   • ✗ Embedding instructions directly into custom Claude Skills within the .claude/skills/ folder.

     Skills are designed for reusable functional units rather than passive architectural enforcement across a file system.

2. 2 When running Claude Code in a CI/CD pipeline, what is the primary operational constraint of using the --headless flag compared to the standard interactive mode?

   Think about the challenges of running a tool designed for conversation in an automated, script-based environment.

   All interactive confirmation prompts are bypassed or require pre-authorization.

   Headless mode is designed for non-interactive environments where the system cannot wait for a user to manually approve actions or plan steps.

   • ✗ The model is restricted to read-only access of the file system.

     Headless mode still allows file modifications; the restriction is on the nature of user input and interaction.

   • ✗ The Agent SDK is disabled, forcing the use of basic prompt-response loops.

     The underlying agentic capabilities remain active; only the interface for user feedback is altered.

   • ✗ Claude Code cannot access network resources or external MCP servers.

     Network and MCP access are governed by security settings and environment variables, not by the headless UI flag.

3. 3 An architect needs to distinguish between personal preferences and team-wide standards for Claude Code. According to the recommended hierarchy, where should team-enforced coding standards reside?

   The correct location must be accessible to version control systems like Git to ensure all team members receive the same updates.

   <project_root>/CLAUDE.md

   Placing the file in the project root allows it to be version-controlled and shared across the entire development team.

   • ✗ ~/.claude/CLAUDE.md

     This location is reserved for global, personal configurations that apply to every project the individual developer works on.

   • ✗ <project_root>/settings.json

     While project-specific, this file is used for configuration parameters like model versions rather than markdown-based coding instructions.

   • ✗ .claude/memory.json

     Agent memory is typically a runtime artifact for tracking state rather than a place for static, team-wide standard definitions.

4. 4 In Claude Code, what is the specific advantage of using 'Plan Mode' when performing a complex refactor involving more than $10$ source files?

   This mode is designed as a 'look before you leap' feature for high-stakes modifications.

   It requires the model to generate and present a summary of intended changes for human approval before execution.

   Plan mode acts as a safety gate, ensuring the developer can verify the logic and scope of a multi-file change before any bytes are modified on disk.

   • ✗ It enables the model to bypass token limits by processing files in parallel segments.

     Plan mode does not change the fundamental token limits or parallelization logic of the underlying model.

   • ✗ It switches the model to Claude 3 Haiku to reduce costs for large-scale code analysis.

     Plan mode is an operational state, not an automatic model-routing or cost-optimization feature.

   • ✗ It automatically creates a git branch and commit for every modified file to prevent data loss.

     While it may suggest git actions, the primary focus is the pre-execution verification of the logic, not the git workflow itself.

5. 5 Which Claude Code feature allows a developer to define reusable, markdown-based functional units that can be invoked across different projects?

   Think about 'Agentic Customization' which involves extending the model's capabilities with specific, named instruction sets.

   Claude Skills

   Skills are reusable functional units defined in markdown that extend Claude's capabilities and can be shared or invoked dynamically.

   • ✗ Custom Slash Commands

     Slash commands are typically for local session management or triggering specific project-bound logic rather than general reusable skills.

   • ✗ MCP Resource Templates

     MCP resources focus on exposing external data and systems, whereas Skills focus on instructions and agentic capabilities.

   • ✗ Prompt Caching Checkpoints

     Caching is a performance and cost optimization technique, not a method for defining reusable functional logic.

6. 6 A developer uses the command `claude --auto` to address a complex bug. What distinguishes 'Auto-mode' from a standard interactive session?

   This mode focuses on the agent's ability to drive a multi-step process toward a resolution independently.

   It allows the model to enter a self-correcting loop to execute multiple tool calls sequentially without user intervention.

   Auto-mode enables the agent to act autonomously to reach a goal, making consecutive decisions and tool calls until the task is complete.

   • ✗ It forces the model to use the most expensive available model for every turn.

     Auto-mode controls the loop behavior, not the specific model selection logic, which is usually pre-configured.

   • ✗ It automatically commits code to the main branch after every successful test run.

     Claude Code respects standard safety and version control boundaries; auto-committing to main is not a default auto-mode behavior.

   • ✗ It provides real-time mathematical analysis of code complexity using the $\mathcal{O}(n)$ notation.

     While Claude can perform this analysis, it is a capability of the model's reasoning, not a defining feature of the auto-mode execution loop.

7. 7 When configuring a custom slash command in Claude Code, which file is used to define the command's trigger and associated logic within a project?

   Look for the file that typically handles key-value pairs for technical tool configuration rather than markdown instructions.

   settings.json

   Slash commands and other behavioral settings for the Claude Code CLI are defined within the JSON-based configuration files.

   • ✗ CLAUDE.md

     CLAUDE.md is for project instructions; slash commands require more structured configuration for execution.

   • ✗ .claude/history.log

     This file is for audit trails and session tracking, not for defining active command logic.

   • ✗ package.json

     While it may contain scripts that Claude can run, it is not the primary configuration point for internal Claude Code slash commands.

8. 8 A developer wants Claude Code to ignore a specific legacy directory containing large binary files to save context. Where is the most appropriate place to define this exclusion?

   Think about the standard file most developers already use to keep search tools and version control from looking at specific folders.

   The .gitignore file at the project root.

   Claude Code typically respects standard .gitignore rules to determine which files should be excluded from its repository context.

   • ✗ A 'don't read' list inside CLAUDE.md.

     While instructions help, the programmatic standard of .gitignore is more reliable and efficient for tool-level exclusion.

   • ✗ A 'deny' rule in a custom MCP server.

     MCP servers expose external data; they are not used to filter the local project directory that Claude Code is already indexing.

   • ✗ Increasing the token limit in settings.json to include the binary data.

     Increasing limits is a cost-heavy solution that doesn't solve the core need for efficient context management.

9. 9 Which of the following describes the correct behavior of 'Agent Memory' in a Claude Code session?

   Consider how an agent maintains 'continuity' during a long debugging process.

   It persists task-relevant information and 'learned' project context across multiple turns within a session.

   Agent memory allows the model to keep track of its progress, discovered bugs, and project nuances as it works through a multi-step task.

   • ✗ It stores the entire code repository in a vector database for RAG retrieval.

     Memory is generally for tracking session-specific state and context, not for full-scale repository indexing.

   • ✗ It creates a backup of the file system to allow for an 'undo' command.

     File system state is managed by the OS or Git; Claude's memory is a cognitive artifact, not a backup utility.

   • ✗ It synchronizes variables between the CLI and the Anthropic Console web interface.

     The CLI and Console sessions are typically isolated; memory is local to the active environment/session.

10. 10 How does the 'stop_reason' field in the Messages API influence the behavior of an agentic system like Claude Code?

    This field is critical for handling responses that are too long for a single API turn.

    It indicates if the model has successfully completed its thoughts or was cut off by a token limit.

    Agents use 'stop_reason' to determine if they need to request more tokens to finish a response or if they should proceed to the next tool execution phase.

    • ✗ It specifies which MCP server caused a fatal crash in the integration layer.

      This field is part of the API response metadata for the model output, not a diagnostic for external infrastructure failures.

    • ✗ It provides a security flag if a jailbreak attempt was detected in the user prompt.

      While related to safety, 'stop_reason' is primarily a technical control for response completeness (e.g., 'end_turn' vs 'max_tokens').

    • ✗ It defines the duration of the wait period before a retried request can be sent.

      Wait periods for retries are managed by rate-limiting headers and client-side backoff logic, not the 'stop_reason' field.

11. 11 What is the primary function of the `.claude/rules/` directory in a repository?

    Think of this as a way to provide 'local context' that only applies when Claude is 'looking' at a specific part of your project.

    To host a set of granular, path-targeted instructions that Claude must follow when interacting with specific modules.

    This directory allows for modular 'rules' files that target specific areas of the code, providing more precise guidance than a single global file.

    • ✗ To store API keys and secrets in a local-only environment.

      API keys should never be stored in instructions or rules; they belong in environment variables or specialized secret managers.

    • ✗ To serve as a cache for model responses to reduce API costs by $50\%$.

      Response caching is handled by the API provider's infrastructure (e.g., Anthropic's prompt caching), not local rule files.

    • ✗ To provide the binaries for custom slash commands compiled from TypeScript.

      Claude Code is typically an interpreted environment or uses standard system commands; it does not compile binaries from a rules folder.

12. 12 In the context of Claude Code, what does 'Headless Mode' lack that 'Auto-mode' typically includes?

    Focus on the differences between a 'human-in-the-loop' experience and an automated script execution.

    Interactive terminal feedback and manual step-by-step confirmation prompts.

    Headless mode is optimized for scripts and CI/CD where no human is present to view progress bars or click 'approve' on individual steps.

    • ✗ The ability to execute shell commands.

      Both modes can execute shell commands; headless just does so without an interactive TTY (Teletype).

    • ✗ The capacity to read files larger than $1$ megabyte.

      Mode selection does not impose arbitrary file size limits; these are governed by the model's context window.

    • ✗ Access to the Model Context Protocol (MCP) servers.

      MCP access is a core engine feature and is available regardless of the UI mode being used.

13. 13 A developer wants to share a specific 'Skill' for optimizing React components across multiple teams in the organization. What is the best practice for skill portability?

    Portability is best achieved through version-controlled files that can be dropped into a standard project structure.

    Distributing the skill as a standalone markdown file that can be placed in a project's .claude/skills/ directory.

    This approach allows the skill to be versioned, shared, and easily added to any project that needs it.

    • ✗ Hard-coding the skill into the global CLAUDE.md file on every developer's machine.

      This is difficult to maintain and update across a large organization.

    • ✗ Defining the skill as a prompt injection string to be used at the start of every session.

      This is a security anti-pattern and is inefficient for long-term capability extension.

    • ✗ Compiling the skill into a custom MCP server.

      While possible, skills are intended to be instruction-based (markdown); MCP is better suited for data and external system integration.

14. 14 Which command is used to initialize a new repository for use with Claude Code, ensuring the creation of necessary configuration files?

    Most developer tools use a four-letter word starting with 'i' to begin a project's configuration.

    claude init

    'claude init' sets up the repository by creating initial configuration files like CLAUDE.md to guide the model's behavior.

    • ✗ claude start

      'claude start' is not a standard initialization command for repository setup.

    • ✗ npm install claude

      This installs a package but does not perform the repository-level initialization and configuration setup required for Claude Code.

    • ✗ git init --claude

      Git is a separate tool; while Claude Code works with Git, it does not use Git flags for its own initialization.

15. 15 When building an agentic loop, what is the 'PostToolUse' hook primarily used for?

    Think about the need for safety and validation in a non-deterministic agent loop.

    Implementing programmatic guardrails to validate the state of the system after an action has been taken.

    Hooks allow developers to run deterministic code to check if a tool's output is safe or if the system is still in a valid state before the model continues.

    • ✗ Automatically committing changes to the Git repository after a tool finishes.

      While a hook could do this, it is not its primary architectural purpose, and auto-committing is often discouraged without validation.

    • ✗ Reducing the API latency by $200$ms by caching the tool's result.

      Latency and caching are infrastructure concerns, not the primary focus of lifecycle hooks in the Agent SDK.

    • ✗ Translating the tool's output from JSON into a human-readable PDF report.

      Hooks are for control flow and validation; UI transformations are usually handled at the presentation layer.

16. 16 Which of the following describes the most secure way to handle sensitive API keys when developing with Claude Code?

    The answer involves a standard DevOps practice for managing 'Secrets'.

    Setting them as environment variables on the host system or within a CI/CD secrets manager.

    Environment variables are the standard, secure way to pass sensitive credentials to tools without exposing them in the codebase.

    • ✗ Including them in the CLAUDE.md file as 'Environmental Context'.

      Placing secrets in markdown files is a major security risk as they could be committed to version control.

    • ✗ Providing them as plain text within a 'Select TWO' prompt response.

      Manually providing secrets in prompts is insecure and violates the principle of keeping credentials out of the model's instruction context where possible.

    • ✗ Hard-coding them into a custom Skill under .claude/skills/.

      Hard-coding secrets is always an anti-pattern, regardless of the directory structure.

17. 17 When Claude Code encounters a conflict between a rule in `~/.claude/CLAUDE.md` and one in `<project_root>/CLAUDE.md`, which one takes precedence?

    Think about how CSS or Git configurations handle local versus global settings.

    The project-level <project_root>/CLAUDE.md takes precedence.

    Local configurations are more specific and are designed to override broader, global settings to ensure project-specific standards are met.

    • ✗ The global ~/.claude/CLAUDE.md takes precedence because it defines the developer's core identity.

      Global settings are meant to be generic; project-specific settings must be able to override them to meet specific repository needs.

    • ✗ Both rules are concatenated, and the model must resolve the logic non-deterministically.

      Configuration systems generally follow a deterministic 'most-specific wins' precedence rule to avoid ambiguity.

    • ✗ Claude Code refuses to start until the conflict is manually resolved in settings.json.

      Conflict resolution is built into the tool's hierarchy logic; manual intervention is not required for standard overrides.

18. 18 A developer wants to use Claude Code to perform a large-scale refactor across multiple microservices. What is the most effective way to coordinate instructions across these repositories?

    Consider the protocol designed to bridge the gap between models and external, reusable data/instruction sources.

    Using a shared Model Context Protocol (MCP) server that provides a consistent 'prompts' resource to all sessions.

    MCP servers can provide centralized, reusable prompts and instructions that multiple Claude Code instances can consume to ensure consistency.

    • ✗ Copy-pasting the same instructions into every single terminal session.

      This is inefficient and error-prone, lacking a 'single source of truth' for the standards.

    • ✗ Storing the instructions in a shared Slack channel and having Claude 'read' the screen.

      Screen reading is an unreliable and unstructured way to provide technical instructions to a CLI tool.

    • ✗ Writing the instructions in the project root's .gitignore file.

      The .gitignore file is for excluding files, not for providing architectural instructions or coordinating refactors.

19. 19 In the context of Claude Code operation, what is 'Agentic Hierarchy'?

    Think about how a human manager works with specialized team members.

    A design pattern where a supervisor agent delegates specialized tasks to one or more subagents.

    Hierarchy in agentic systems allows a main 'manager' agent to maintain high-level context while subagents handle specific, bounded technical tasks.

    • ✗ The permission levels of different users on a Linux filesystem.

      Filesystem permissions are OS-level; agentic hierarchy refers to the organization of AI agents themselves.

    • ✗ The sequence of commands in a shell script from top to bottom.

      This is linear execution, not an agentic hierarchy involving delegation and context isolation.

    • ✗ The ranking of Claude models from Haiku to Opus based on intelligence.

      This is a model performance tier list, not an operational architectural pattern for agents.

20. 20 How does Claude Code determine which 'Skills' are available for use in a specific project directory?

    The answer lies in the directory structure of the repository itself.

    It scans the .claude/skills/ directory in the current project root and its parents.

    Claude Code looks for skills in the standard project structure, allowing for both repo-specific and potentially inherited skills.

    • ✗ It checks the developer's LinkedIn profile for verified AI certifications.

      Skill availability is determined by technical configuration files, not by external social media or certification status.

    • ✗ It asks the user to manually type out the markdown for every skill at the start of a session.

      This defeats the purpose of 'reusable' skills; they are designed to be loaded automatically from the file system.

    • ✗ It connects to a central Anthropic Skill Registry via the cloud.

      While a registry might exist in the future, current operation relies on local or team-managed directories for skill definition.

21. 21 What is the primary risk of using 'Select ALL' responses in an agentic loop without sufficient guardrails?

    Focus on the 'safety' implications of letting an autonomous agent run without oversight.

    The agent may enter an infinite loop of destructive actions if it incorrectly interprets a tool's failure.

    Without proper 'stop_reason' handling and hooks, an agent might continue to try and 'fix' a situation using destructive tools, leading to compounding errors.

    • ✗ The model will consume too many tokens and hit a rate limit.

      While cost is a factor, the primary risk in a hard-difficulty engineering context is usually system safety and reliability.

    • ✗ The model will switch to a non-English language to try and resolve the bug.

      This is a rare and non-critical failure mode compared to the risk of destructive system actions.

    • ✗ The .claude/rules/ directory will be deleted automatically.

      Tools do not typically delete their own configuration directories as a result of an unconstrained loop.

22. 22 A developer wants to use Claude Code to automatically generate a pull request description. Which built-in command or feature is best suited for this?

    Consider the modularity of 'slash commands' and 'skills' for custom workflows.

    A custom slash command that triggers a 'summarize changes' skill.

    Custom slash commands paired with skills are the standard way to extend Claude Code with specific, repeatable workflows like PR generation.

    • ✗ claude pr-create

      This is not a standard built-in command for Claude Code; it typically uses its reasoning to generate content rather than having a fixed 'pr' flag.

    • ✗ Setting 'auto-pr' to 'true' in settings.json.

      Settings.json is for parameters, not for enabling complex, multi-step agentic workflows like summarizing and creating PRs.

    • ✗ Deleting the .git folder so Claude can start fresh.

      Deleting version control history is a destructive action that prevents rather than helps with PR generation.

23. 23 Which of the following is a valid use case for 'Headless Mode' in an enterprise environment?

    Look for a scenario that describes automation and 'no human present'.

    Running a nightly script that uses Claude to audit code for security vulnerabilities and log results.

    Headless mode is ideal for automated tasks that run without human intervention, such as cron jobs or CI/CD audits.

    • ✗ Pair-programming with a senior developer in a live VS Code session.

      Pair-programming is inherently interactive and benefits from the standard, non-headless TTY mode.

    • ✗ Interviewing candidates to see how they interact with an AI assistant.

      Interviews are interactive; headless mode would hide the very interaction the interviewer needs to observe.

    • ✗ Debugging a complex UI issue that requires viewing browser artifacts.

      Headless CLI tools are text-based; they are not the primary interface for visual debugging of browser-based UI issues.

24. 24 Why is it important to include 'System Isolation' through subagents when working on a project with a very large context $(\approx 200,000$ tokens)?

    Think about the cognitive load on a human�or an AI�when they have to remember too many things at once.

    To prevent 'Context Drift' where the model loses focus on the primary task due to too much irrelevant data.

    By delegating to subagents with smaller, targeted context windows, the system maintains higher precision and avoids the 'lost in the middle' phenomenon.

    • ✗ Because Claude 3.5 Sonnet can only read $10,000$ tokens at a time.

      Modern Claude models have much larger context windows; isolation is about quality and focus, not a hard $10k$ limit.

    • ✗ To ensure that every subagent is charged a separate, lower API fee.

      Fees are based on total token consumption; using more agents may actually increase costs, but it improves reliability.

    • ✗ To allow the model to use the $\mathcal{O}(log n)$ search algorithm instead of linear search.

      Search algorithms are part of the model's internal weights or tool implementation; subagents are an architectural pattern, not a search optimization.

25. 25 A team uses a 'PreToolUse' hook to check for the presence of a 'STAGING' environment variable before allowing a 'deploy' tool to run. This is an example of:

    Focus on the word that describes a 'hard stop' or 'safety gate' implemented in code.

    Deterministic Guardrails

    Guardrails implemented via hooks provide a programmatic, reliable way to enforce safety rules that cannot be bypassed by model hallucinations.

    • ✗ Prompt Engineering

      This is a programmatic code-level check, not an instruction written in a prompt.

    • ✗ Model Optimization

      Optimization focuses on cost, latency, or quality; safety hooks are a functional requirement for reliability and security.

    • ✗ Context Engineering

      While it affects how the model proceeds, it's about enforcing a rule rather than managing the structure or volume of the context window.