Claude Code Operation: CCDV-F study guide

Claude Code Operation is the only topic in Domain 3, Claude Code, so its 3.1% is the whole domain. It tests whether you can run Claude Code day to day: put each customisation in the right component, manage sessions, use slash commands, and run without a person at the keyboard.

What the official guide covers

The Claude Certified Developer Foundations exam guide (version 1.0, effective July 2026) describes this topic as Claude Code's core components, its features, the CLAUDE.md hierarchy, repository initialisation and settings.json configuration:

The five components and where they live

A skill and a command file with the same name create the same slash command; skills add supporting files and frontmatter such as description, disable-model-invocation, allowed-tools and context: fork. You write CLAUDE.md, Claude writes auto memory, and /memory edits the first and toggles the second. Both are context, not enforcement; to block an action every time, use a hook.

Why Claude Code skips a rule you wrote

When an instruction is ignored, the cause is usually where it lives, not how it is worded:

A path-scoped rule looks like this; it loads only when Claude reads or edits a matching file:

---
paths:
  - "src/db/**/*.sql"
---
Every SQL change in src/db opens and commits an explicit transaction.

Repository initialisation

Run /init in a new repository. Claude reads the codebase and writes a CLAUDE.md with build commands, test instructions and conventions. If one exists, /init suggests improvements instead of overwriting it. With CLAUDE_CODE_NEW_INIT=1, it runs an interactive flow that also offers skills and hooks. Commit the result.

Session management

Slash commands

Built-in commands most likely to appear on the exam:

Custom slash commands are skills you write; in headless mode, put /skill-name in the prompt string. Skills from a plugin are prefixed with the plugin's name, so run-tests in a plugin called payments runs as /payments:run-tests; two plugins can ship the same skill name without a clash, and renaming a plugin renames every command it ships.

Headless and streaming mode

claude -p "<prompt>" runs once without the interface and exits non-zero on failure. Output formats:

• --output-format text (default): plain text.
• --output-format json: one object with result, session_id, cost and usage; --json-schema adds checked data in structured_output.
• --output-format stream-json: newline-delimited JSON events, with --verbose; add --include-partial-messages for tokens as they are generated.

--input-format stream-json lets a program send messages on stdin. --bare turns off auto-discovery of CLAUDE.md, auto memory, hooks, skills, plugins and MCP servers, so a script behaves the same on every machine; it is recommended for scripts and needs ANTHROPIC_API_KEY. CI use is covered in CCAR-F 3.6.

#!/usr/bin/env bash
set -euo pipefail

# First pass: review a diff, no prompts, JSON result
out=$(git diff origin/main...HEAD | claude --bare -p "List bugs in this diff. Bugs only." \
  --allowedTools "Read" \
  --permission-mode dontAsk \
  --max-turns 5 \
  --output-format json)

echo "$out" | jq -r '.result'
session_id=$(echo "$out" | jq -r '.session_id')

# Follow-up in the same session
claude --bare -p "Suggest one test per bug." --resume "$session_id" --output-format json | jq -r '.result'

# Live view for a dashboard: stream text tokens as they arrive
claude --bare -p "Explain the last build failure in build.log" --allowedTools "Read" \
  --output-format stream-json --verbose --include-partial-messages |
  jq -rj 'select(.type == "stream_event" and .event.delta.type? == "text_delta") | .event.delta.text'

Auto mode and the other permission modes

A permission mode sets what Claude can do without asking. Switch with Shift+Tab or start with --permission-mode.

In auto mode a second model, the classifier, reviews actions and blocks risky ones by default, such as force pushes, production deploys and sending sensitive data out. Repeated blocks make Claude Code fall back to prompting. The docs warn that auto mode reduces prompts but does not guarantee safety. The classifier judges whether an action is risky, not whether the code works, so pair an unattended run with a Stop hook that runs the tests and exits 2 on failure, which sends Claude back to work. A defaultMode of auto is ignored in project settings files; set it in user or managed settings or pass --permission-mode auto.

Pick the mode by asking what breaks if an action runs unchecked, not by how many prompts you want to avoid. Two details catch people out:

• acceptEdits also approves rm, rmdir, mv, cp and sed on paths inside the working directory. A broad pattern can delete files there with no prompt; only default mode asks first.
• bypassPermissions drops the protected-path prompts too, so writes to repository and Claude configuration go through. Deny rules still block in every mode, so set them on sensitive directories before you relax the mode.

For unfamiliar or high-stakes code, work in three phases: explore and plan in plan mode, review the plan for paths you did not expect, then switch mode to let the edits run.

Rules that decide exam answers

• Skills load on demand; CLAUDE.md always loads. Universal standards go in CLAUDE.md or rules, task workflows in skills; new commands belong in .claude/skills/, though .claude/commands/ still works.
• -p for no-human runs. Use --output-format json to parse, or stream-json with --verbose for live events.
• Branch to explore, compact to save space. Only /branch keeps the original conversation intact.
• Auto mode is a classifier, not a guarantee. It screens risk, not correctness: hard rules need deny rules or hooks, tests need a Stop hook, and unattended CI suits dontAsk with allow rules.
• Bare mode for reproducible scripts. Without --bare, -p loads the same local configuration as an interactive session.
• Scope comes from frontmatter, not folders. A rule needs paths to load selectively, and a subagent needs skills to see a skill.

Where it appears in the exam

Domain 3, Claude Code, is 3.1% of the exam and is this one topic, so expect one or two items out of 53. Questions describe a developer using Claude Code (a filling context window, a script that needs machine-readable output) and ask for the right component, command or flag.

Two sample questions

These are original Timo practice questions. They are not official exam questions.

Question 1

A developer runs Claude Code from a script and wants an internal dashboard to show Claude's answer token by token while it is being written. Which invocation fits?

A. claude -p "<prompt>" --output-format jsonB. claude -p "<prompt>" --verboseC. claude -p "<prompt>" --output-format stream-json --verbose --include-partial-messagesD. claude -p "<prompt>" --input-format stream-json

Answer: C. Streamed JSON with partial messages emits text deltas as they are generated. A returns one object at the end. B adds logging to text output without a parseable event stream. D changes how input is sent, not how output arrives.

Question 2

After an hour of analysis in Claude Code, a developer wants to try a risky refactoring approach. If it fails, they want to return to the conversation exactly as it stands now. What should they do?

A. Run /clear and start the refactor in an empty conversation.B. Run /branch and try the refactor in the new branch.C. Run /compact to summarise, then try the refactor.D. Run /rewind to an earlier point and try the refactor from there.

Answer: B. /branch creates a branch of the conversation, switches into it and preserves the original, which they can return to with /resume. A starts without the hour of analysis. C summarises the same conversation, leaving no untouched original. D moves back in time instead of keeping both paths.

Build exercise

1. Run /init, then add a rule with a paths field and confirm it loads only for matching files.
2. Turn a prompt you type often into a skill and call it from claude -p "/name".
3. Run the script above on a real diff, with and without --bare, and compare.
4. Name a session with -n, /branch it, and move between branches with /resume.

Practise this topic

• Claude Certified Developer practice exam: free, 20 questions, no sign-up
• CCDV-F study guide: all topics
• Worked example: CLAUDE.md hierarchy
• Same topic in another exam: 3.1 CLAUDE.md hierarchy
• Previous topic: Configuration Management
• Next topic: Debugging and Error Handling

Sources

• Claude Certified Developer Foundations Exam Guide, version 1.0, effective July 2026 (Anthropic), Domain 3 topic: Claude Code Operation
• Claude Code documentation: Run Claude Code programmatically
• Claude Code documentation: Commands
• Claude Code documentation: How Claude remembers your project
• Claude Code documentation: Choose a permission mode