Scenario: Code Generation with Claude Code

Scenario Description

You're tasked with accelerating a software development workflow using Claude Code. The agent must support code generation for new features, refactoring of legacy modules, debugging of failing tests, and documentation generation. The key is integrating Claude Code seamlessly into the development process through custom slash commands, CLAUDE.md configuration hierarchies, and choosing between plan mode (for complex multi-file changes) and direct execution (for single-file fixes).

This scenario requires understanding how to configure Claude Code at multiple levels—user-wide defaults, project-level overrides, and directory-specific settings—to tailor the experience for different contexts. You'll design custom commands (e.g., /test-drive, /refactor-module) that developers use frequently, and implement skill files with CLAUDE.md frontmatter that define context scope, allowed tools, and execution safety boundaries.

The developer feedback loop is critical: after Claude Code generates code, you need iterative refinement through test-driven iteration and the "interview pattern" (Claude Code asks clarifying questions before acting). Plan mode lets you review multi-file changes before committing; direct execution is fast but risks incomplete understanding of side effects.

Domains Tested

Key Concepts to Study

Claude Code Configuration & Workflows

CLAUDE.md hierarchy: user-level ~/.claude.md defaults, project-level ./CLAUDE.md overrides, directory-specific settings for microservices or monorepos
Custom slash commands in .claude/commands/: defining command syntax, context injection, tool restrictions
Skill files with SKILL.md frontmatter: context: fork for isolated skills, allowed-tools lists, version pinning
Plan mode vs. direct execution: trade-offs between review certainty and speed

Context Management & Reliability

Iterative refinement: using test output and error messages to guide Claude Code toward correct solutions
The interview pattern: when Claude Code should ask "Are you sure?" before executing irreversible operations (e.g., refactoring public APIs)
Test-driven iteration: feeding test results back into Claude Code prompts to narrow problem space
Managing context across multiple commands: persisting project knowledge (dependencies, naming conventions) via CLAUDE.md

Study Tips for This Scenario

Design CLAUDE.md as a Config as Code: Treat CLAUDE.md like you would a linting config or CI/CD file. Specify exactly which tools Claude Code can use, what directories are off-limits (e.g., /vendor), and what your testing standards are. This ensures consistency across team members and prevents accidental mistakes.
Create High-Leverage Custom Commands: Identify the 3–5 most common development workflows (e.g., "generate a new API route", "write tests for this function") and turn them into slash commands. Each command should include prompt templates that inject the current file context and test standards automatically.
Practice Plan Mode for High-Impact Changes: Use plan mode when refactoring across multiple files, adding new dependencies, or changing core abstractions. Review the proposed changes, ask Claude Code to explain side effects, and then approve execution. This catches subtle bugs before they hit version control.
Combine Test Output with Interview Pattern: When Claude Code generates code, immediately run your test suite and pipe failures back into the conversation. Use the interview pattern to ask "Why did test X fail?" and let Claude Code reason through the fix. This creates a tight feedback loop that improves code quality.