Claude Code Operation

What this skill covers

Domain 3 is Claude Code, and it is 3.1% of the CCDV-F exam. The single task statement is Claude Code Operation: rules, skills, commands, agents, agent memory, session management, slash commands, headless and streaming and auto mode, the CLAUDE.md hierarchy, repository initialization, and settings.json.

The exam is asking where a behavior lives. Guidance that the model reads is a different file from configuration the client enforces. A session is a different store from memory that survives the session. A skill that loads on demand is a different budget from a file that loads on every turn.

Rules, skills, and commands

Rules are markdown under .claude/rules/. A file with no paths frontmatter loads at session start, the same way project CLAUDE.md does. A paths list of globs loads when Claude reads a matching file, so test conventions stay out of a session that is editing API handlers. A matching rule is added to the other instructions. It does not erase the root file. paths is the field the client reads from rule frontmatter.

A skill is a directory with SKILL.md, under .claude/skills/ for the team or ~/.claude/skills/ for you. Typing the skill name after / runs it. The body enters context when the skill is invoked or when the model decides it applies, so a long deploy procedure does not sit in every turn. A flat markdown file dropped into the skills directory is not that skill. The older .claude/commands/ layout still creates a slash command from a single markdown file.

Built-in slash commands control the session: /help, /init, /memory, /context, /clear, /compact, /resume, /plan, /permissions, /config, /status, /doctor, /cost, /agents, and /hooks. Custom names come from skills and commands the project or your user directory defines. / on an empty prompt lists what this session can run.

• Always-on convention: CLAUDE.md or an unscoped rule.
• Convention for one file type: a rule with paths.
• Procedure you invoke: a skill or a command.
• Verbose procedure that should not fill the main transcript: a skill with context set to fork.

Agents and agent memory

A subagent is its own Claude session for one subtask. Project agents live as markdown under .claude/agents/. Personal agents live under ~/.claude/agents/. /agents lists and edits them. The file names the agent, describes when to use it, and can limit tools, pick a model, set a permission mode, or isolate the work in a git worktree. The main session receives the result the subagent returns. The subagent's tool chatter stays in its own window.

By default a subagent starts with a fresh context. It does not already know the parent conversation. A fork is the exception: it branches with the parent transcript. If the parent has spent an hour discovering which files matter, the spawn prompt has to carry those facts, or the parent should fork.

Agent memory here means auto memory, the notes Claude writes for itself. They live under ~/.claude/projects/ for that git repository, shared across worktrees on this machine and not copied by git. MEMORY.md is an index. The first 200 lines, or the first 25KB, load at the start of a conversation. Topic files load when Claude opens them. The parent auto memory is not handed to a subagent unless that subagent is a fork. A subagent can keep a separate memory directory of its own.

Auto memory is still context. Claude Code loads it so the model can see a preference you corrected last week. It does not block a tool. /memory opens the instruction files and the auto-memory toggle. /context shows which memory files this session actually loaded.

Sessions and the slash commands that move them

A session is one conversation, from launch until you exit or the process ends. It has a transcript. Project instructions persist across sessions. The transcript does not, unless you resume it.

/clear, also /reset and /new, drops the conversation and keeps CLAUDE.md and auto memory. /compact summarizes the conversation so far so the window has room. /resume and claude --resume reopen a named or numbered session. claude --continue, or -c, reopens the latest conversation in this directory. --fork-session with a resume creates a new session id and leaves the original transcript alone. /rewind rolls the conversation, and optionally the files, back to a checkpoint.

Use a fresh session when the next task has nothing to do with the last one. Resume when the unfinished work is still in that transcript. Compact when the work is the same but the middle of the transcript is noise. Clear when the history itself is the problem and the files on disk already hold the project facts.

CLAUDE.md and starting a repository

CLAUDE.md is instructions you write. Claude reads applicable files at the start of a session, and nested files when it reads a file in that directory. The locations, from broad to narrow, are the managed organization file, ~/.claude/CLAUDE.md, the project file at CLAUDE.md or .claude/CLAUDE.md, and CLAUDE.local.md beside it. All of the files that apply are concatenated. Content closer to the directory where you launched is read later. CLAUDE.local.md is appended after CLAUDE.md in the same directory. Later does not mean it wins. If two instructions contradict, the model may follow either one.

The project file is what a clone receives. The user file and CLAUDE.local.md stay on your machine when they are gitignored. @path imports are inlined when the file loads, so splitting a long file does not shrink the context. A managed CLAUDE.md is still guidance. Blocking a command is a permissions.deny entry or a hook.

/init explores the codebase and writes a starter CLAUDE.md with the build, test, and layout it finds. If a CLAUDE.md already exists, /init proposes edits instead of replacing the file. Set CLAUDE_CODE_NEW_INIT=1 when you want that flow to also offer skills and hooks and to wait for a review before it writes. That is repository initialization: the first session records facts so later sessions do not rediscover them.

settings.json

settings.json is enforced by the client: permissions, hooks, model, and other keys. When the same key is set in more than one place, the higher level replaces the lower one. Highest first: managed settings from the organization, then command-line flags and --settings for this session, then .claude/settings.local.json, then the shared .claude/settings.json, then ~/.claude/settings.json. A flag does not outrank a managed key.

List keys such as permissions.allow are combined across files, so a user allow-list does not erase a project deny. A few keys ignore project and local files. permissions.defaultMode set to auto or bypassPermissions is one of them: those values are read from user or managed settings, or from --permission-mode for a single launch. A committed defaultMode of auto does not turn auto on for the team.

Commit .claude/settings.json for the permissions and hooks the clone should start with. Keep personal exceptions in settings.local.json, which is meant to stay out of git. Check what loaded with /status. Check which instruction files loaded with /context.

{
  "permissions": {
    "allow": ["Bash(npm test)"],
    "deny": ["Read(./.env)", "Read(./.env.*)"]
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{ "type": "command", "command": ".claude/hooks/block-force-push.sh" }]
      }
    ]
  }
}

Headless, streaming, and auto mode

Headless work is print mode: claude -p "prompt" runs the query and exits, so a script or a CI job can call it. Nobody is sitting at the keyboard, so a permission prompt is a failure. Pair the invocation with an explicit --permission-mode, an allow-list such as --allowedTools, and deny rules for anything the job must not touch. --output-format is text, json, or stream-json. stream-json with --include-partial-messages and --verbose is the streaming form: the caller sees tokens as they are produced instead of one blob at the end.

--bare skips auto-discovery of hooks, skills, plugins, MCP servers, auto memory, and CLAUDE.md so a script starts from a known surface. It is the opposite of a normal interactive session. --no-session-persistence, print mode only, leaves nothing to resume.

Auto is a permission mode in the Shift+Tab cycle, alongside manual, accept-edits, and plan. A classifier lets low-risk actions through and escalates the rest. accept-edits auto-approves file edits and still asks for shell commands. Plan mode researches and proposes and does not edit until you leave it. bypassPermissions skips the checks and belongs in an isolated environment, not on a workstation that holds credentials. Auto is not that skip. Start a session in a chosen mode with --permission-mode. The old --enable-auto-mode flag is gone.

claude -p "Run npm test and report failures" \
  --output-format stream-json --include-partial-messages --verbose \
  --permission-mode dontAsk \
  --allowedTools "Bash(npm test)"

The test style that rode along on every turn

A team pasted fifty lines of test conventions into the root CLAUDE.md. Editing a migration paid for those tokens. Moving them to .claude/rules/testing.md with a paths glob for test files keeps them out until a test file is read. The root file still loads. The rule adds to it. A /review skill holds the long checklist that should appear only when someone types the command.

The CI job that waited for a keyboard

A pipeline called claude with a prompt and no -p. The process opened an interactive session and stalled on a permission prompt. The job that works is print mode, stream-json if the runner wants incremental output, dontAsk or an allow-list that names npm test, and a deny for force-push. --bare is appropriate when the runner must not inherit a developer's auto memory and extra skills.

The preference that never cloned

One engineer says "remember we use pnpm." Claude writes auto memory on that machine. A teammate's clone still runs npm. Auto memory is not in git. The instruction that the team shares is a line in project CLAUDE.md, or a hook if the wrong package manager must be refused rather than discouraged.