Developer Tooling & Agentic Coding•20% of Exam Score
Code Generation with Claude Code
Claude Code is Anthropic's agentic CLI tool designed for autonomous engineering tasks. This domain tests your architectural understanding of planning workflows, codebase indexing, custom slash commands, and safety boundaries.
Exam Syllabus Deep Dive
Core Architectural Principles Tested
Topic 1
Planning Mode vs. Direct Execution
Complex multi-file refactors require separating the discovery/planning phase from code mutation.
Architectural Best Practice:Require the agent to generate an implementation_plan.md and obtain explicit developer sign-off before making edits.
Topic 2
.claude/rules/ Directory & Path Scoping
Global system prompts dilute context when working across diverse polyglot codebases.
Architectural Best Practice:Use scoped rule files with glob pattern headers (e.g., paths: ['**/*.ts', 'src/api/**']) to inject domain rules only when relevant.
Topic 3
Subagent Worktree Isolation
Concurrent agents modifying the same git working tree cause file corruption and merge conflicts.
Architectural Best Practice:Isolate subagents in separate git worktrees (`git worktree add`) or branched workspaces to allow parallel execution safely.
High-Yield Exam Rules to Remember:
- Always inspect and verify before mutating code in large enterprise repositories.
- Scope rules hierarchically using path globbing rather than one massive system prompt.
- Use subagents for narrow, isolated exploration tasks to protect main context window budgets.
Interactive Practice
Sample Questions from this Domain (18 Total)
Sample Question #1 (Q#4)Code Generation with Claude Code
Situation Context:You need a custom `/review` command for standard code review that is available to the whole team when they clone the repository.
Where should you create the command file?
A`.claude/commands/` in the project repository
B`~/.claude/commands/`
CRoot `CLAUDE.md`
D`.claude/config.json`
Explanation & Architectural Rationale:Project commands stored in `.claude/commands/` are version-controlled and automatically available to everyone. B is for personal commands. C is for instructions, not command definitions. D does not exist.
Sample Question #2 (Q#5)Code Generation with Claude Code
Situation Context:You need to restructure a monolith into microservices (dozens of files, service-boundary decisions).
What approach should you use?
APlanning mode: explore the codebase, understand dependencies, design an approach
BDirect execution incrementally
CDirect execution with detailed up-front instructions
DDirect execution and switch to planning when it gets hard
Explanation & Architectural Rationale:Planning mode is designed for large changes, multiple possible approaches, and architectural decisions. B risks expensive rework. C assumes you already know the structure. D is reactive.
Sample Question #3 (Q#6)Code Generation with Claude Code
Situation Context:A codebase has different conventions across areas (React, API, database). Tests are co-located with code. You want conventions to be applied automatically.
What approach should you use?
A`.claude/rules/` files with YAML frontmatter and glob patterns
BPut everything in the root CLAUDE.md
CSkills in `.claude/skills/`
DCLAUDE.md in every directory
Explanation & Architectural Rationale:`.claude/rules/` with glob patterns (e.g., `**/*.test.tsx`) enables automatic convention application based on file paths—ideal for tests spread across the codebase. B relies on model inference. C is manual/on-demand. D does not work well when relevant files are in many directories.