20 Questions — Domain 7 : Developer Productivity & Operational Enablement Quiz

Expand any question to reveal the correct answer and explanation.

1. 1 A new developer on your team reports that Claude Code is ignoring the organization's standardized testing conventions, even though the conventions are defined in a file on their machine. Upon investigation, you find the instructions are located in the developer's ~/.claude/CLAUDE.md file. What is the correct architectural fix to ensure these conventions are applied for the entire team?

   Consider the scope and visibility of configuration files within a version-controlled environment.

   Move the testing conventions to a project-level CLAUDE.md file in the root of the repository and commit it to version control.

   Project-level configuration files committed to the repository are the standard mechanism for propagating shared team behaviors and coding standards.

   • ✗ Instruct all developers to manually copy the testing conventions into their own ~/.claude/CLAUDE.md files.

     User-level configurations are personal and unshared, making manual synchronization across a team inefficient and prone to version drift.

   • ✗ Configure a personal variant in the ~/.claude/skills/ directory to override the default behavior for all users.

     The ~/.claude/skills/ directory is scoped to the local user and cannot be used to enforce or share global standards across a multi-user project.

   • ✗ Use the /memory command to force the local instance to load the user-level file before every session.

     While the /memory command can verify loaded files, it does not solve the underlying issue of sharing configuration across a distributed development team.

2. 2 You are managing a monolithic repository with multiple distinct packages. You want to maintain modular configuration files to avoid a single, massive CLAUDE.md file while ensuring package-specific standards are applied. Which syntax should you use within a package's CLAUDE.md to reference external standard files?

   Look for a specific symbol used to pull in external content into a Markdown-based configuration.

   The @import syntax to selectively include external files relevant to each package.

   The @import syntax allows architects to maintain modularity by importing specific, relevant standards into localized CLAUDE.md files.

   • ✗ The #include directive followed by the relative path to the standards file.

     Claude Code configuration does not use the #include directive; this is likely a confusion with C-style preprocessor directives.

   • ✗ The YAML frontmatter 'extends' field to inherit properties from a base configuration.

     Inheritance-based extension is not the primary mechanism for combining text-based instruction files in the CLAUDE.md hierarchy.

   • ✗ The 'paths' glob pattern in the project-level .mcp.json configuration.

     .mcp.json is used for Model Context Protocol server configurations rather than the hierarchical organization of instruction-based CLAUDE.md files.

3. 3 Your team is experiencing 'context bloat' because universal coding standards are being loaded even when developers are working on configuration-only files. You decide to implement path-scoped rules in .claude/rules/. Which formatting is required at the top of these rule files to ensure they only activate for Terraform files?

   Think about how metadata is typically embedded at the start of a file to control its behavior.

   YAML frontmatter containing the 'paths' field with a glob pattern like ["terraform/**/*"].

   YAML frontmatter with path scoping allows rules to load conditionally, reducing irrelevant context and optimizing token usage.

   • ✗ A standard Markdown header: # Terraform Rules.

     Markdown headers are for organization and readability but do not provide the programmatic scoping instructions required for conditional activation.

   • ✗ A slash command definition in the .claude/commands/ directory mapping to the file.

     Slash commands are for on-demand execution of specific tasks, not for the automatic, conditional loading of conventions based on file type.

   • ✗ An @import statement inside the root CLAUDE.md file pointing to the rule.

     Importing a rule into the root CLAUDE.md would make it always-loaded, defeating the purpose of reducing context through path-scoping.

4. 4 You are tasked with migrating a legacy microservice architecture, which involves coordinated changes across 50+ files and complex architectural trade-offs. According to Claude Code best practices, which execution mode is most appropriate for the initial phase of this task?

   Consider the scale and complexity of the task and whether it requires investigation before implementation.

   Plan mode to enable safe codebase exploration and design before committing to changes.

   Plan mode is specifically designed for complex, multi-file tasks where exploring approaches and making architectural decisions is critical.

   • ✗ Direct execution to implement changes immediately as the model identifies them.

     Direct execution is reserved for simple, well-scoped changes where the path forward is already clearly defined and understood.

   • ✗ Non-interactive mode using the -p flag to automate the entire migration in one pass.

     Automating complex architectural shifts without human feedback or planning is high-risk and likely to lead to costly rework.

   • ✗ Using a separate Agent SDK script to bypass the standard Claude Code environment.

     While the Agent SDK is powerful, Claude Code's plan mode is the integrated tool specifically optimized for large-scale codebase refactoring and analysis.

5. 5 You are integrating Claude Code into a GitHub Actions CI/CD pipeline to automate code reviews. To prevent the pipeline from hanging indefinitely while waiting for user input, which CLI flag must be included in the execution command?

   Identify the flag that controls the mode of interaction between the tool and the environment.

   The -p (or --print) flag to run in non-interactive mode.

   The -p flag ensures that Claude Code operates in a non-interactive manner, which is essential for automation in CI/CD pipelines.

   • ✗ The --resume flag to skip the initialization check.

     The --resume flag is used to continue a previous interactive session and does not address the requirement for non-interactive execution.

   • ✗ The --output-format json flag to suppress standard output.

     While formatting output as JSON is useful for machine parsing, it does not inherently prevent the tool from pausing for interactive input.

   • ✗ The --json-schema flag to validate input parameters.

     The --json-schema flag is used to enforce a specific structure for the output, not to control the interactivity of the terminal session.

6. 6 A developer wants to create a specialized 'brainstorming' tool for the team that generates long lists of architectural alternatives. To prevent these verbose outputs from cluttering the main conversation history and exhausting the context window, which frontmatter configuration should be used in the SKILL.md file?

   Look for a setting that implies branching or separating the current task into its own process.

   context: fork

   The context: fork option runs the skill in an isolated sub-agent context, preventing verbose exploratory output from polluting the main conversation window.

   • ✗ allowed-tools: ["Read", "Write"]

     Restricting allowed tools limits the actions the agent can take but does not isolate the session's conversational output from the main thread.

   • ✗ argument-hint: "Describe the system architecture"

     An argument hint provides guidance to the user on what parameters to provide but has no impact on session isolation or context management.

   • ✗ paths: ["**/*"]

     Universal path-scoping ensures the rule is always active but does not create an isolated execution environment for specific skills.

7. 7 In an enterprise environment, you need to expose a shared internal documentation catalog to Claude Code for all developers to use. Where should you configure this MCP server to ensure it is shared via version control while keeping individual developer credentials secure?

   Focus on the mechanism that balances team-wide availability with the 'least privilege' and 'no secrets in code' principles.

   In a project-level .mcp.json file using environment variable expansion like ${DOCS_TOKEN}.

   Project-level configuration allows for sharing via version control, while environment variable expansion ensures secrets are not committed to the repository.

   • ✗ In a user-level ~/.claude.json file to avoid affecting other developers' local setups.

     User-level configuration is not shared via version control, meaning other team members would not automatically receive the shared documentation tool.

   • ✗ Embedded directly in the root CLAUDE.md file within a code block.

     CLAUDE.md is for instructions and conventions; technical server configurations for MCP must be handled in designated JSON configuration files.

   • ✗ In the .claude/commands/ directory as a custom shell script.

     While slash commands can trigger scripts, the standard and most efficient way to manage MCP tool discovery is through .mcp.json.

8. 8 During a complex debugging session, you suspect that Claude is operating with stale information because a colleague recently committed changes to a different part of the codebase. Which command allows you to verify exactly which configuration and memory files are currently loaded into the agent's context?

   Identify the slash command specifically designed to surface the agent's internal state regarding its knowledge sources.

   The /memory command to view active memory and config files.

   The /memory command is the standard way to diagnose inconsistent behavior by verifying which memory and CLAUDE.md files are active.

   • ✗ The /compact command to refresh the session state.

     The /compact command is typically used to summarize or reduce the current context window, not to audit loaded configuration files.

   • ✗ The --resume flag followed by the session ID.

     Resuming a session continues the existing context but does not provide a specific audit of loaded configuration hierarchies.

   • ✗ The /compact command followed by the fork_session command.

     This combination of commands handles context management and session branching but is not a direct tool for auditing loaded configuration files.

9. 9 You are designing a CI/CD workflow where Claude Code reviews its own generated pull requests. Why is it architecturally recommended to use an independent Claude instance for the review pass rather than the same session that generated the code?

   Consider the cognitive principle of 'independence' in the context of verification and quality control.

   To avoid 'reasoning context' bias, where the agent is less effective at identifying its own errors.

   Isolation ensures that the reviewer evaluates the code objectively based on the files alone, without being influenced by the initial generation logic.

   • ✗ To bypass the token limits of a single long-running session.

     While token limits exist, the primary reason for instance separation is related to reasoning quality and independence, not just capacity.

   • ✗ Because the Messages API does not support multi-turn tool calling in CI/CD environments.

     The Messages API fully supports multi-turn interactions; this is not a technical limitation that necessitates instance separation.

   • ✗ To enable the use of the -p flag, which is only supported for first-turn requests.

     The -p flag supports the full non-interactive execution of a task and is not limited to the first turn of a conversation.

10. 10 When debugging an operational issue across multiple wrapper modules, what is the most efficient sequence of tools to use to minimize unnecessary context usage?

    Think about the pattern of 'incremental discovery' versus 'brute-force loading'.

    Start with Grep to find error entry points, then use Read to follow imports and trace flows.

    This incremental approach builds codebase understanding logically while preserving context for critical reasoning steps.

    • ✗ Read all files in the relevant directories to find the error source immediately.

      Reading all files upfront is inefficient and can lead to context exhaustion; incremental discovery is the preferred architectural pattern.

    • ✗ Use Glob to list all files, then use Edit to insert log statements in every file.

      Mass-editing files is a destructive and inefficient way to trace execution flows compared to targeted searching and reading.

    • ✗ Use Bash to run a recursive 'grep -r' and then pipe the output into a temporary file for Claude to Read.

      While functional, using the built-in Grep tool is more direct and allows the agent to reason more effectively about the specific search results.

11. 11 An architect is splitting a massive 1,500-line CLAUDE.md into smaller files in .claude/rules/ to improve maintainability. Which of the following conventions would be best suited for a path-scoped rule rather than a subdirectory CLAUDE.md file?

    Consider which pattern is more effective for 'cross-cutting' concerns that ignore directory boundaries.

    A specific testing convention that applies to all files ending in .test.tsx regardless of their location in the project.

    Glob-pattern rules in .claude/rules/ are ideal for applying cross-cutting conventions to specific file types scattered across multiple directories.

    • ✗ A standard for API response formatting used only in the /routes directory.

      Conventions isolated to a single directory tree are well-suited for subdirectory-level CLAUDE.md files.

    • ✗ A list of team members and their specific areas of expertise.

      Personnel information is not a path-specific convention and belongs in a more central, always-loaded configuration or project README.

    • ✗ A set of deployment procedures used only by the DevOps team in the /infra folder.

      Localized procedures for a specific functional directory are easier to manage within that directory's own CLAUDE.md hierarchy.

12. 12 You are configuring a custom skill in .claude/skills/SKILL.md that requires a 'service-name' parameter. To ensure the developer is prompted for this value if they forget to provide it, which frontmatter field should be used?

    Look for the property that suggests providing a 'clue' or 'reminder' for missing information.

    argument-hint

    The argument-hint field is used to prompt the user for required parameters when a skill is invoked without the necessary arguments.

    • ✗ allowed-tools

      This field is used to restrict the tools available to the agent during the skill's execution, not for parameter validation.

    • ✗ context: fork

      This controls the execution environment of the skill (isolated vs. shared context) rather than the user input requirements.

    • ✗ YAML paths scoping

      Path scoping is used to conditionally load rules based on the files being edited, which is unrelated to on-demand skill invocation.

13. 13 A team is using Claude Code in a CI/CD pipeline to generate structured JSON findings for PR comments. Which combination of CLI flags is required to ensure the output is machine-parseable and adheres to a specific format?

    Identify the two flags that specifically handle the 'what' and 'how' of structured machine communication.

    --output-format json and --json-schema

    This combination enforces structured output and validates it against a provided schema, making it ideal for automated CI integrations.

    • ✗ --print and --json-schema

      While --print enables non-interactive mode, it must be combined with --output-format json to actually change the output stream to JSON.

    • ✗ --resume and --output-format json

      The --resume flag is for continuing interactive sessions and is generally not used in automated pipeline passes.

    • ✗ -p and --resume

      These flags are contradictory for automated use, as -p is for non-interactive passes and --resume is for interactive context continuation.

14. 14 An architect is advising a team on when to provide multiple coding issues to Claude in a single message versus sequential messages. Which scenario justifies providing all issues in a single message?

    Consider the 'dependencies' between the problems being solved.

    When the problems are interacting, where fixing one may require a change in how another is addressed.

    Interacting problems require the model to consider the holistic context to prevent rework or incompatible solutions.

    • ✗ When the issues are independent and do not affect the same files.

      Independent problems are better handled sequentially to keep the focus tight and reduce the risk of complex merge conflicts or errors.

    • ✗ When the project-level CLAUDE.md is very large and token usage must be minimized.

      The size of the configuration file does not dictate the refinement strategy for specific bug fixes or feature implementations.

    • ✗ When using plan mode for a single-file bug fix with a clear stack trace.

      Single-file bug fixes with clear traces are better suited for direct execution and sequential refinement if multiple issues exist.

15. 15 You are configuring a CI/CD pipeline that re-runs Claude Code reviews on every new commit in a PR. To improve developer experience and avoid cluttering the PR, what is the recommended skill to apply regarding previous findings?

    Think about how a human reviewer would use their memory of a previous 'pass' to provide a better follow-up review.

    Include prior review findings in the context and instruct Claude to report only new or still-unaddressed issues.

    Providing history allows the agent to behave as a persistent reviewer, avoiding duplicate noise and tracking progress across commits.

    • ✗ Clear the session context completely and start each review as if it were the first commit.

      This approach is inefficient and leads to duplicate comments on issues that may have already been acknowledged but not yet fixed.

    • ✗ Instruct Claude to always delete previous comments before posting new ones using the Bash tool.

      Deleting comments removes the audit trail of the review process and can be destructive; filtering output is a more robust strategy.

    • ✗ Use the /compact command to remove all previous findings from the context to save on token costs.

      Compacting context summarizes history but doesn't specifically address the logic needed to prevent duplicate reporting of known issues.

16. 16 A developer is using Claude Code to analyze a codebase for security vulnerabilities. They use the 'Explore' subagent during their investigation. What is the primary architectural benefit of this approach for this specific scenario?

    Consider the impact of 'information density' on the model's ability to maintain focus over long interactions.

    It isolates verbose discovery output and returns only summaries to preserve the main conversation context.

    Isolating discovery prevents 'lost in the middle' effects and context exhaustion during the high-volume information gathering phase.

    • ✗ It allows the developer to bypass the project's CLAUDE.md safety constraints.

      The Explore subagent remains subject to the same configuration and safety hierarchy as the main agent.

    • ✗ It grants the agent access to restricted Bash commands that are disabled in the main thread.

      Subagents inherit their tool permissions from the parent orchestrator; they do not automatically gain elevated privileges.

    • ✗ It automatically enables the -p flag for non-interactive background analysis.

      Subagent spawning is a model-driven architectural choice, while flags like -p are CLI-driven operational choices.

17. 17 In the context of operational enablement, an architect is designing a 'Multi-Pass' review architecture for a mission-critical financial application. What does this design typically involve?

    Focus on how the review task is 'decomposed' into different logical stages of analysis.

    Splitting reviews into focused per-file passes for local issues plus separate integration passes for cross-file data flows.

    Decomposing the review by scope (local vs. global) improves reasoning precision and prevents the model from missing subtle integration bugs.

    • ✗ Passing the same prompt to the model three times and choosing the most common answer.

      This is a simple 'majority vote' pattern and does not constitute a structured multi-pass architectural design for complex code analysis.

    • ✗ Requiring a human to pass every AI-generated line of code through a manual linter before commit.

      This is a human-in-the-loop (HITL) gate, which is distinct from the automated 'Multi-Pass' review strategy used by AI agents.

    • ✗ Running one pass using Haiku for speed and a second pass using Opus for correctness.

      While model-tier routing is a useful optimization, a 'multi-pass' architecture specifically refers to the decomposition of the review logic itself.

18. 18 Which of the following is a critical 'trap' that architects must avoid when designing automated verification passes in a CI/CD environment?

    Look for the answer that suggests an over-reliance on simplified, high-level indicators of system performance.

    Treating a single overall accuracy metric as a guarantee of safety for the entire system.

    Aggregate metrics can hide per-slice failures; professional architects use stratified sampling and per-case evaluations.

    • ✗ Using a second independent Claude instance for the review.

      Instance separation is a recommended best practice to avoid reasoning bias, not a trap to be avoided.

    • ✗ Allowing the model to self-report confidence alongside findings to assist in triage.

      Confidence scoring is a valuable metadata layer that helps calibrate the routing of findings to human reviewers.

    • ✗ Using a JSON schema to validate the outputs of the review agent.

      Schema validation is a deterministic programmatic gate and is a core requirement for reliable CI/CD integrations.

19. 19 When configuring shared development environments for a large engineering team, what is the best practice for managing secrets needed by project-scoped MCP servers?

    Think about the 'environment variable' approach common in standard DevOps practices.

    Use environment variable expansion in the project-scoped .mcp.json.

    This allows the configuration to be version-controlled without exposing sensitive credentials, as they are injected at runtime from the environment.

    • ✗ Store the secrets in the user-level ~/.claude/CLAUDE.md file.

      CLAUDE.md is not designed for secret management, and user-level files are not automatically accessible to the project-scoped .mcp.json.

    • ✗ Hardcode the secrets in the .mcp.json file but only on a private branch of the repository.

      Hardcoding secrets anywhere in the repository, even on private branches, is a major security anti-pattern and risks credential leakage.

    • ✗ Require every developer to manually enter the secret into the Claude Code prompt at the start of every session.

      This is highly inefficient, degrades developer productivity, and increases the risk of credentials being stored in plain text in conversation logs.

20. 20 What is the recommended approach for organizing a massive set of disparate team standards in a project with many subdirectories?

    Consider the principle of 'conditional activation' based on the developer's current focus.

    Topic-specific rule files in .claude/rules/ with glob-pattern frontmatter for conditional activation.

    This modular approach improves maintainability and ensures only the relevant standards are loaded for the current task, optimizing token usage.

    • ✗ A single monolithic CLAUDE.md file in the root directory to ensure all rules are always loaded.

      Monolithic files lead to context bloat and can cause the model to miss specific instructions as they lose influence in a long context window.

    • ✗ Converting all standards into individual skills that must be manually invoked by developers.

      While skills are useful for on-demand tasks, general standards and conventions should be applied automatically to maintain consistency.

    • ✗ Placing a CLAUDE.md file in every single directory, even if they share the same conventions.

      This leads to massive duplication and maintenance overhead compared to using glob-pattern rules in a central .claude/rules/ directory.