20 Questions — Domain 3 : Claude Code Configuration & Workflows

Expand any question to reveal the correct answer and explanation.

1. 1 A new developer joins your team and clones the project repository. They report that Claude Code is not following the established architectural standards defined in the team's $~/.claude/CLAUDE.md$ file. Why is the developer experiencing this issue?

   Consider which levels of the configuration hierarchy are typically included in a git repository.

   User-level settings in ~/.claude/CLAUDE.md apply only to the local user and are not shared via version control.

   Configuration hierarchy dictates that user-scoped files are personal and do not persist across repository clones for other team members.

   • ✗ The developer needs to manually run the /load command to sync the user-level configuration from the original author.

     There is no '/load' command for syncing user-level markdown files across different machines.

   • ✗ The project-level CLAUDE.md file is likely corrupted, preventing the user-level file from being inherited correctly.

     User-level and project-level files are independent; a project-level error would not stop a local user-level file from functioning for that specific user.

   • ✗ Claude Code requires a specific environment variable, CLAUDE_SYNC_GLOBAL, to be set to true to read from the home directory.

     Claude Code reads the user-level hierarchy by default without requiring specialized environment variable flags.

2. 2 Your project has testing standards that must apply to all files matching the pattern $**/*.test.tsx$, regardless of their directory. What is the most maintainable way to implement this in Claude Code?

   Think about how to conditionally load conventions based on file naming patterns.

   Create a file in .claude/rules/ with YAML frontmatter specifying the glob pattern in the 'paths' field.

   Path-scoped rules using glob patterns allow for conditional loading, ensuring conventions are only applied to relevant files while reducing context bloat.

   • ✗ Place a duplicate CLAUDE.md file in every subdirectory that contains a test file.

     Duplicating configuration files leads to high maintenance overhead and potential inconsistencies as standards evolve.

   • ✗ Add a comprehensive 'Testing' section to the root CLAUDE.md and instruct Claude to look for it when editing any file.

     Monolithic files increase token usage and context noise by providing irrelevant instructions for non-test files.

   • ✗ Use a project-level .mcp.json file to map specific file extensions to mandatory system prompts.

     The .mcp.json file is used for configuring Model Context Protocol servers, not for path-based markdown rule activation.

3. 3 You are creating an 'Agent Skill' in $.claude/skills/codebase_analysis.md$ that explores complex dependencies. You want to ensure that the extensive output from this discovery phase does not exhaust the context window of your main conversation. Which frontmatter configuration should you use?

   Look for a setting that creates a separate branch for the skill's execution.

   context: fork

   The 'context: fork' option runs the skill in an isolated sub-agent context, preventing verbose exploratory data from polluting the main session.

   • ✗ isolation: true

     This is not a recognized frontmatter parameter for Claude Code Agent Skills.

   • ✗ mode: autonomous

     While skills are agentic, 'mode: autonomous' does not specifically address context isolation or window management.

   • ✗ subagent: explore

     While the Explore subagent exists, 'subagent' is not the correct frontmatter key for configuring skill isolation.

4. 4 Your team is planning to migrate a large monolith to microservices, a task involving changes to 50+ files and significant architectural boundary decisions. Which Claude Code mode is most appropriate for the initial phase of this task?

   Consider which mode focuses on design and exploration before execution.

   Plan mode, because it enables safe codebase exploration and architectural design before committing to file modifications.

   Plan mode is specifically designed for complex tasks requiring architectural decisions and large-scale, multi-file changes.

   • ✗ Direct Execution mode, because it allows for immediate, incremental changes as boundaries are discovered.

     Direct execution on high-complexity tasks risks costly rework and inconsistent service boundaries due to lack of upfront design.

   • ✗ Interactive mode with the /compact command enabled to preserve memory during the long migration.

     /compact is a session management tool, not a functional mode for architectural planning.

   • ✗ Headless mode with the -p flag to ensure the model follows a pre-defined migration script without deviation.

     Headless mode is for CI/CD automation, not for exploratory architectural design which requires human-in-the-loop validation.

5. 5 An automated CI/CD pipeline script invokes Claude Code to review a Pull Request, but the job hangs indefinitely and eventually times out. What is the most likely cause?

   Automated environments cannot provide the feedback Claude usually expects from a terminal user.

   The pipeline is not using the -p (or --print) flag, causing Claude Code to wait for interactive user input.

   In automated environments, the non-interactive '-p' flag is required to prevent the process from stalling on a request for user confirmation.

   • ✗ Claude Code has exceeded its token budget for the daily CI run.

     Token budget exhaustion would typically result in an error message rather than an indefinite hang.

   • ✗ The CLAUDE.md file in the repository contains a /plan command that requires a manual override.

     Slash commands like /plan are interactive tools and would not be executed as part of a static configuration file initialization.

   • ✗ The CI environment lacks a valid .mcp.json file, causing a connection retry loop.

     Missing MCP configurations usually lead to tool unavailability rather than blocking the entire execution indefinitely.

6. 6 You want to keep your project's $CLAUDE.md$ modular by separating team-specific standards from general coding conventions. Which syntax allows you to reference external standards files within $CLAUDE.md$?

   Think of a directive often used in stylesheets or modern languages for modularity.

   @import "path/to/file.md"

   The '@import' syntax is specifically used to keep CLAUDE.md modular by referencing external files relevant to specific packages or domains.

   • ✗ #include "path/to/file.md"

     This is a C-style preprocessor directive, not the syntax used by Claude Code.

   • ✗ !link(path/to/file.md)

     This is not valid syntax for modular configuration in Claude Code.

   • ✗ <<[path/to/file.md]

     This syntax is not used by Claude Code for importing or referencing external rule sets.

7. 7 A developer is creating a 'Security Audit' skill. To prevent the agent from accidentally modifying the codebase during the audit, which frontmatter parameter should be configured in the $SKILL.md$ file?

   Look for a way to explicitly define which functions the agent can invoke.

   allowed-tools: ["Read", "Grep", "Glob"]

   The 'allowed-tools' parameter restricts the agent's capabilities during skill execution, preventing destructive actions like 'Write' or 'Edit'.

   • ✗ read-only: true

     This is not a valid frontmatter key; tool restrictions are handled through more granular tool access lists.

   • ✗ prevent-modifications: yes

     This is not a standard configuration property for Agent Skills.

   • ✗ capabilities: ["search", "read"]

     Capability-based naming is used in some SDKs, but Claude Code specifically uses a tool-allow-list.

8. 8 You have been investigating a bug in a named session resumed with $--resume bug-fix-123$. After several unsuccessful attempts, you want to explore an entirely different refactoring approach without losing the current investigation's history. What is the best command to use?

   Think of a term used in version control to create a new path from a shared point.

   fork_session

   The 'fork_session' command creates an independent branch from the shared analysis baseline, allowing for divergent exploration.

   • ✗ /compact

     This command compresses the current session log to save tokens; it does not create a new session branch.

   • ✗ --new-session

     Starting a completely new session would lose the initial codebase analysis and context already established.

   • ✗ /memory

     This command is used to verify loaded memory files, not to manage session state or branches.

9. 9 When using Claude Code for complex discovery tasks, why is it architecturally preferable to use the 'Explore' subagent rather than performing all discovery in the main session?

   Consider the impact of large amounts of raw data on a conversation's focal point.

   It isolates verbose discovery output, returning only summaries to preserve the main conversation context.

   Isolating discovery prevents the main session's context window from being filled with raw data, which can lead to 'lost-in-the-middle' effects.

   • ✗ The Explore subagent has a larger context window than the main session agent.

     Both typically operate within the same model constraints, but they manage token distribution differently.

   • ✗ The Explore subagent is significantly cheaper per token than the main session agent.

     Costs are determined by the underlying model; using a subagent actually adds a small coordination overhead.

   • ✗ The Explore subagent is the only way to access restricted built-in tools like Bash and Glob.

     The main agent can also access built-in tools unless specifically restricted by 'allowed-tools' configuration.

10. 10 You are integrating Claude Code into a CI pipeline for automated pull request feedback. You want the output to be machine-parseable for a downstream script that posts inline GitHub comments. Which CLI configuration is required?

    Identify the flags used to enforce a specific machine-readable format and its structure.

    claude -p --output-format json --json-schema "schema_definition_here"

    Using '--output-format json' with '--json-schema' ensures that the headless output is structured and valid for automated consumption.

    • ✗ claude -p --format json --schema-file pr_review.json

      While 'json' is correct, the specific flag names in the example are incorrect based on the Claude Code documentation.

    • ✗ claude --print --structured-mode

      The flag '--structured-mode' is not a standard CLI option for Claude Code; schema enforcement is done through specific JSON flags.

    • ✗ claude -p --github-mode

      Claude Code does not have a native '--github-mode'; integration is achieved via structured JSON output and custom scripts.

11. 11 You have defined a custom slash command in $~/.claude/commands/deploy.sh$. Why is this command not appearing for your teammates when they run Claude Code in the same project repository?

    Differentiate between global user configuration and project-specific repository files.

    The command is stored in a user-scoped directory (~/.claude/commands/) rather than a project-scoped directory (.claude/commands/).

    User-scoped commands are personal and stay on the local machine; project-scoped commands are committed to the repository and shared.

    • ✗ Slash commands must be written in Python to be shared across different operating systems.

      Command language is not the issue; the storage location in the hierarchy is the primary factor for visibility.

    • ✗ The developer needs to run /reload-commands to sync with the global command registry.

      Claude Code does not use a central 'global registry' that requires a sync command for local files.

    • ✗ Claude Code only shares commands defined within CLAUDE.md using the @command directive.

      CLAUDE.md is for rules and context, while specific command files are stored in the '.claude/commands' directory.

12. 12 When configuring conventions for a project, why would an architect choose path-specific rules in $.claude/rules/$ over placing $CLAUDE.md$ files in multiple subdirectories?

    Think about conventions that apply to specific file types spread across the entire project structure.

    Path-specific rules use glob patterns to apply conventions to matching files regardless of their directory location.

    Glob patterns (e.g., in .claude/rules/) allow conventions to span the entire codebase without the need for redundant, directory-bound configuration files.

    • ✗ Path-specific rules load globally, whereas subdirectory CLAUDE.md files are ignored by sub-agents.

      Sub-agents follow the same configuration hierarchy as the main agent.

    • ✗ Subdirectory CLAUDE.md files are only effective if they contain at least 100 lines of instructions.

      There is no minimum line requirement for configuration files to be effective.

    • ✗ CLAUDE.md files in subdirectories cause a 'context loop' that can crash the Claude Code CLI.

      While inefficient, subdirectory overrides are a supported part of the hierarchy and do not cause system crashes.

13. 13 Claude Code's behavior in your project has become inconsistent. You suspect that a conflicting rule is being loaded from a forgotten configuration file. Which command should you use to troubleshoot this?

    Look for a command that helps you see what Claude is 'remembering' about your project setup.

    /memory

    The '/memory' command allows you to verify which memory/configuration files are currently loaded and diagnose inconsistent behavior.

    • ✗ /compact

      This command reduces history tokens and does not provide a diagnostic report of active configuration files.

    • ✗ /rules

      While it sounds relevant, '/rules' is not a standard Claude Code command for inspecting the configuration hierarchy.

    • ✗ /context --list

      This is not the correct command for diagnosing configuration file loading issues in Claude Code.

14. 14 You are designing an Agent Skill that requires a specific project name as an input. You want to ensure that if a developer forgets to provide the name, Claude Code proactively prompts them for it. Which frontmatter setting should you use?

    Identify the frontmatter key used to provide a nudge or tip for missing parameters.

    argument-hint: "Please provide the target project name."

    The 'argument-hint' frontmatter is used to prompt developers for required parameters when a skill is invoked without them.

    • ✗ required-args: ["project_name"]

      This is not the documented frontmatter key for prompting users for missing arguments.

    • ✗ prompt-on-empty: project_name

      This property does not exist in the Agent Skills frontmatter specification.

    • ✗ input-validation: { project_name: "required" }

      Skill frontmatter uses simpler key-value pairs rather than complex validation objects for argument prompting.

15. 15 According to the principles of test-driven iteration in Claude Code, what is the most effective way to guide the agent through a progressive improvement of a failing feature?

    Focus on providing concrete, deterministic evidence of failure to guide the model.

    Writing a test suite first and sharing the specific test failures with the agent to guide fixes.

    Sharing concrete test failures provides deterministic feedback, allowing the model to refine its output until it meets a defined pass criterion.

    • ✗ Writing a detailed prose description of why the current implementation is logically flawed.

      Prose can be ambiguous; the model may interpret descriptions inconsistently across different iterations.

    • ✗ Increasing the max_tokens limit to allow the model more 'thinking' space during code generation.

      Context size does not improve logical accuracy or provide a feedback loop for iterative refinement.

    • ✗ Resetting the session after every failed attempt to prevent 'stale logic' from influencing the next run.

      Resetting prevents the agent from learning from its previous mistakes, which is counterproductive to iterative improvement.

16. 16 You are using Claude Code to fix multiple bugs in a single session. When should you provide all issues in one message versus addressing them sequentially?

    Consider the relationship between the problems being solved.

    Provide all issues at once when the fixes for the issues are likely to interact with each other.

    Interacting issues require the model to consider the unified system state, which is best handled by presenting the related context together.

    • ✗ Provide all issues at once when the problems are independent and do not overlap.

      Independent problems are easier to fix sequentially to prevent the model from getting distracted or overwhelmed.

    • ✗ Always provide issues sequentially to minimize token usage and avoid 'lost-in-the-middle' effects.

      While sequential is common, it is not an 'always' rule; interacting issues are an exception that require simultaneous context.

    • ✗ Provide all issues at once only if you are using the Message Batches API to save on costs.

      Cost optimization is a separate concern from the logical decomposition of debugging tasks.

17. 17 Why is it recommended to use a second, independent Claude instance to review code generated by the first instance in a CI/CD pipeline?

    Consider the benefit of a 'fresh pair of eyes' in a standard software engineering review.

    The generating instance is less effective at reviewing its own changes because it lacks fresh perspective and objectivity.

    An independent reviewer does not share the generator's internal reasoning context, allowing it to catch assumptions or errors the generator overlooked.

    • ✗ To double the speed of the code review by using parallel processing resources.

      Speed is not the primary driver; architectural integrity and objectivity are the focus of multi-instance patterns.

    • ✗ Anthropic's security policy requires a dual-signature model for all code modifications.

      While good practice, this is a procedural choice rather than a hard-coded technical requirement of the platform.

    • ✗ A second instance is required because the first instance's context window will be full after generation.

      Generating code does not necessarily fill the context window, and a fresh session could be used on the same instance.

18. 18 In long-running Claude Code sessions, you notice response times are increasing and the model is becoming less responsive. Which command helps manage history tokens without losing the high-level summary of the session?

    Think of a term for making something smaller and more dense while keeping its core.

    /compact

    The '/compact' command compresses the session log, preserving modified summaries of past objectives while discarding redundant output tokens.

    • ✗ /clear

      This command typically wipes the session history completely, which is not desired if summaries need to be preserved.

    • ✗ /memory --reset

      Resetting memory would remove all configuration rules and project context, not just conversation history.

    • ✗ /summarize

      While logically similar, '/summarize' is not the standard command used by Claude Code for token management.

19. 19 How does Claude Code handle a directory-level $CLAUDE.md$ file that conflicts with a root-level $CLAUDE.md$ file?

    Think about how scoping works in CSS or file systems, where the more 'specific' rule wins.

    The localized directory-level file overrides the root-level configuration for that specific folder.

    Claude Code's hierarchy follows a precedence rule where directory-specific overrides take priority over more general project-level instructions.

    • ✗ The root-level file takes precedence because it is the primary project configuration.

      In standard configuration hierarchies, the most localized rule (the one closest to the file being edited) usually takes precedence.

    • ✗ Both files are ignored, and Claude reverts to the user-level global configuration.

      Conflicting configurations lead to precedence resolution, not a total abandonment of the project context.

    • ✗ The CLI will throw a 'Hierarchy Conflict' error and refuse to execute any changes until the files are merged.

      Claude Code resolves these conflicts silently based on standard scoping rules.

20. 20 When resuming a named session after a significant period where external code changes were made, why is starting a fresh session with a structured summary sometimes more reliable than using $--resume$?

    Consider the state of 'truth' regarding the files when context is preserved from the past.

    The resumed session may contain stale tool results that contradict the current state of the codebase.

    Resuming context from a time before code was modified means Claude's internal model of the files is outdated, leading to errors.

    • ✗ Resuming a session consumes double the tokens as a fresh session.

      Resuming a session does not inherently double token consumption; it is the 'stale' context that is the concern.

    • ✗ Anthropic limits named session persistence to a maximum of 48 hours.

      There is no documentation supporting a 48-hour hard limit on named session persistence.

    • ✗ Named sessions are read-only and cannot be used to perform new file modifications.

      Named sessions are fully interactive and can be used for any standard development task.