Claude Code Commands: CCDV-F Developer Exam Guide

Claude code commands are one of the most underestimated exam topics in the CCDV-F certification. Domain 3 (Claude Code) carries 3.1% of the exam's 53 items, yet the commands, hooks, and configuration choices it covers reappear in Domain 2 (Applications and Integration, 33.1%) whenever a scenario involves a team build pipeline, a CI task, or a headless agent workflow. Getting the mechanics right once pays dividends across the paper.

What are Claude Code commands?

Claude Code commands are slash-prefixed directives entered in the Claude Code terminal. They divide into two categories: built-in commands (shipped with the CLI and always available) and custom commands (Markdown files your team places under a .claude/commands/ directory). Built-ins handle session hygiene and context control; custom commands encode repeatable team workflows as reusable prompt templates.

Both categories are tested. CCDV-F scenarios ask you to choose the right built-in for a given context management problem, and they ask you to design or diagnose a custom command structure for a team that needs consistent output across engineers.

What built-in Claude Code commands should CCDV-F candidates know?

The CCDV-F exam tests practical judgment, not command-name memorisation. That said, the commands below appear in scenarios often enough that you should be able to explain what each does, when to reach for it, and what it cannot do.

The /compact command is the most frequently examined in context-management scenarios (Domain 6, Prompt and Context Engineering, 11.0%). A typical scenario places an agent mid-task with a near-full context window and asks which command preserves working memory without losing the task thread. /compact is almost always the right answer over /clear, because /clear discards history entirely rather than summarising it.

For Claude Code Configuration & Workflows, understand that built-in commands operate at the session layer. They do not alter the project-level CLAUDE.md or the user-level settings file. Scenarios that ask you to persist a behaviour across all future sessions or make it visible to new team members require a configuration file answer, not a slash command answer.

How do custom Claude Code commands work?

Custom commands are Markdown files stored in .claude/commands/ at the project root (for team-wide commands) or ~/.claude/commands/ (for personal commands only). The filename, without the .md extension, becomes the slash command: review_pr.md is invoked as /review_pr.

The file body is a prompt template. The special token $ARGUMENTS is replaced with whatever text the user types after the command name at invocation time. A minimal example:

# /review_pr

Review the pull request at $ARGUMENTS.

Check for:
- Correctness issues (logic errors, off-by-one, null handling)
- Security issues (injection, overly broad permissions)
- Style violations against the conventions documented in CLAUDE.md

Return findings as a JSON array with `severity`, `file`, `line`, and `description` fields.

Invoked as /review_pr https://github.com/acme/api/pull/142, the command substitutes the URL into $ARGUMENTS and fires the prompt.

CCDV-F scenarios on custom commands typically ask you to:

1. Choose between encoding a workflow in a custom command versus in a CLAUDE.md instruction
2. Diagnose why a command produces inconsistent output across engineers
3. Decide whether a command belongs in the project-level or user-level commands directory

The most common wrong answer for category 3 is placing team-wide workflow rules in a personal ~/.claude/commands/ file. That directory is invisible to teammates. Project-level .claude/commands/ is the correct scope whenever output consistency across a team is a requirement.

# Directory structure for team-shared custom commands
.claude/
  commands/
    review_pr.md        # invoked as /review_pr
    generate_tests.md   # invoked as /generate_tests
    summarise_diff.md   # invoked as /summarise_diff
  settings.json
CLAUDE.md

The three-level configuration hierarchy governs which commands are visible in which sessions. Project commands are visible to anyone who opens Claude Code in that repository; personal commands are visible only to the individual user. When both directories define the same command name, the project-level file takes precedence.

How do Claude Code commands map to CCDV-F exam domains?

Domain 3 covers Claude Code commands explicitly, but the concepts surface in other domains whenever a scenario involves automation, pipelines, or team workflows.

That distinction matters for study strategy. Every CCDV-F item tests a specific, named skill. The skills under Domain 3 include designing custom commands, diagnosing scoping failures, and choosing between slash command invocation and a direct API call for a given automation scenario.

What is headless mode and why does it appear in CCDV-F scenarios?

Headless mode runs Claude Code non-interactively. The --print flag (abbreviated -p) accepts a prompt string and writes the model response to stdout, making it composable with shell pipelines and CI automation.

# Invoke a custom command non-interactively in a CI pipeline
claude --print "/review_pr $PR_URL" --output-format json

CCDV-F scenarios involving headless mode typically ask you to identify the correct flag combination for a given CI requirement. Common traps:

• Using /compact in headless mode has no effect: there is no ongoing session to compact
• Custom commands that depend on session memory (/memory, prior conversation context) fail silently in headless mode, because each invocation starts from a blank slate
• --output-format json controls Claude Code's wrapper output, not the model's response format; if you need structured JSON from the model, the custom command prompt must request it explicitly

Understanding built-in tool sequences for common tasks is directly relevant in headless scenarios: an invocation that chains tools (read file, analyse, write report) must sequence every step correctly in the command prompt, since there is no interactive correction available.

How should you design custom commands for CCDV-F scenario questions?

The exam rewards command designs that are deterministic and scope-appropriate. Three principles cover the majority of scenario questions.

Specificity beats generality. A command named /review_security that targets one concern outperforms a generic /review command asked to "check everything." Specific commands produce consistent output; generic ones produce variance that compounds across engineers.

Output format is part of the command. When downstream tools consume the command's output (a CI parser, a ticketing webhook), the command prompt must specify the exact format. Leaving format implicit transfers the decision to the model at runtime, which produces inconsistency across sessions and team members.

Scoping is a correctness issue, not a style preference. A command in the wrong directory either does not exist for some users (project-level command placed in a personal directory) or pollutes teammates' environments with personal shortcuts (personal command in the project directory). CCDV-F scenario questions treat scoping errors as bugs.

The agentic architecture concepts around structured context passing apply directly to custom command design: a command that passes well-structured input produces more reliable output than one that relies on implicit context the model must infer at runtime.

What are the most common mistakes with Claude Code commands on the CCDV-F exam?

Three failure patterns account for most incorrect answers across the Claude Code and Applications domains.

Confusing session state with persistent configuration. Slash commands operate within a session. They cannot write to settings.json or modify CLAUDE.md. A scenario that asks how to make a behaviour permanent or visible to new team members requires a configuration file answer, not a slash command answer.

Treating /compact as lossless compression. The /compact command summarises prior turns; it does not retain them verbatim. Scenarios where a workflow requires exact recall of earlier tool outputs (for example, a multi-step audit that cross-references step 1 outputs in step 5) should not rely on /compact. The correct design writes outputs to structured files or fields rather than depending on the summary to preserve precision.

Assuming custom commands can invoke tools directly. Custom commands are prompt templates. They instruct Claude to use tools; they do not invoke tools themselves. A command like /fetch_metrics cannot directly call an MCP-backed tool. It prompts Claude to call it, which means the relevant MCP tool must be registered in the session's configuration for the command to function end-to-end.

The CCDV-F exam costs $125 per attempt and is scored on a 100-to-1000 scale with a passing mark of 720. With 53 items and eight domains to cover, Claude Code command mechanics are a narrow but reliable source of correct answers for prepared candidates. The adaptive study engine on this platform tracks mastery at the skill level, so gaps in command scoping or headless invocation patterns surface before exam day rather than on it.