CCA-F start here · Domain 3 · Claude Code mind maps

Claude Code mind maps

Everything the CCA-F exam asks about Claude Code, on one page. It starts with which of the six exam scenarios bring Claude Code questions. Then six mind maps, each in the form "what you see, where the fault is, the fix", with the rule to remember, the exam-guide line it comes from, and one practice question.

Domain 3 · 20%Guide 3.1–3.6, plus 1.7, 2.5, 4.1, 4.5, 4.6, 5.4About 30 minutes

Which of the six scenarios ask about Claude Code?

The exam shows you 4 scenarios out of a bank of 6. Three of the six are about Claude Code:

#ScenarioDomainsClaude Code questions?Maps to study
2Code Generation with Claude CodeD3, D5Yes, the core one. CLAUDE.md, slash commands, rules, plan mode1, 2, 3, 5
5Claude Code for Continuous IntegrationD3, D4Yes. -p, JSON output, reviews, false positives4 (and 1)
4Developer Productivity with ClaudeD2, D3, D1Partly. Built-in tools, exploring a codebase, MCP servers6, 2, 5
1Customer Support Resolution AgentD1, D2, D5No (Agent SDK)—
3Multi-Agent Research SystemD1, D2, D5No (Agent SDK)—
6Structured Data ExtractionD4, D5No (API)—
What this means for you. Only three scenarios have no Claude Code, and you get four, so at least one Claude Code scenario always appears. If the four are picked at random, you get scenario 2 or 5 (or both) about 14 times in 15, and both of them about 4 times in 10. The guide doesn't say which ones you'll get, so don't skip any. Domain 3 is 20% of the score, about 12 of the 60 questions.

Guide §5: “4 scenarios drawn from a bank of 6.” Scenario 2: “custom slash commands, CLAUDE.md, plan mode vs direct execution.” Scenario 5: “automated reviews, test generation, PR feedback, minimize false positives.” Scenario 4: “explore codebases, built-in tools (Read/Write/Bash/Grep/Glob), MCP servers.”

First, the picture: where things live

Shared: in the repo, through git CLAUDE.mdalways loaded src/api/CLAUDE.mdonly in that folder .claude/rules/*.mdonly matching paths .claude/commands//review for all .claude/skills/on-demand workflows .mcp.jsonteam MCP servers A new teammate gets all of this on clone. Personal: your home folder ~/.claude/CLAUDE.md ~/.claude/commands/ ~/.claude.json Only you get this. Not in version control.

Most Claude Code questions are really one of two questions: who should get this? (shared or personal) and when should it load? (always, for some paths, or only when asked).

The six maps at a glance

#QuestionUsual answerPractise
1Where does an instruction live?Everyone, always: project CLAUDE.md. Some file types: .claude/rules/ with paths:. Only when asked: a command or skillWhere an instruction lives
2Plan mode or just do it?Many files or a design choice: plan mode. One clear fix: directPlan or just do it
3Claude keeps getting it wrong. How do you iterate?Show examples, write tests first, or let Claude interview youExamples, tests first or interview
4Claude Code in CI-p, JSON output, an independent reviewer, explicit criteriaClaude Code in CI, Self-review, Batch or now
5The session got long or staleResume, fork, start fresh with a summary, or compactResume, fork or fresh, Large codebase
6Which built-in tool?Names: Glob. Contents: Grep. Small change: EditBuilt-in tools

A yellow row in each map is the runner-up: the case where a different answer wins because one fact in the question changes.

Mind map 1: Where does an instruction live?

Ask two questions: who needs it (the team or just me) and when (always, for certain files, or only when someone asks).

What you seeWhere the fault isFix
A new developer's Claude ignores the team's coding standardsThe standards are in someone's ~/.claude/CLAUDE.md, which isn't sharedMove them to the project CLAUDE.md (root or .claude/CLAUDE.md)
A convention applies only inside one folder, like src/api/It's in the root file, so it loads everywhereA directory CLAUDE.md in that folder
Test files are spread across many folders and all follow one conventionA directory file can't follow them around.claude/rules/ file with paths: ["**/*.test.tsx"]
The root CLAUDE.md is huge and hard to maintainEverything is in one fileSplit it with @import or topic files in .claude/rules/
Everyone needs a /review command after cloningIt's in ~/.claude/commands/.claude/commands/ in the repo
A long workflow fills the main chat with noiseIt runs in the main contextA skill with context: fork in its SKILL.md
Claude doesn't seem to follow an instruction at allYou don't know which files loadedRun /memory to see the loaded files
It must happen every single time, with no exceptions (for example, run the formatter after each edit)Any text instruction is followed most of the time, not alwaysA hook, not CLAUDE.md
Rule: CLAUDE.md is always loaded, for standards everyone needs. Rules with paths: load only for matching files. Commands and skills load only when asked. Personal files are never shared. Use a hook when it must never be skipped.

Guide 3.1: “User-level is not shared via version control. @import syntax for modular references. /memory command verifies which memory files are loaded.” Guide 3.2: “Skills = on-demand task workflows; CLAUDE.md = always-loaded universal standards.” Guide 3.3: “Glob-pattern rules beat directory CLAUDE.md for conventions spanning directories.”

Example. Database migration files live in several services' folders. Every migration must follow the same naming and rollback rules, and the team doesn't want these rules in context while editing other files. Where should they go?
  1. A section in the root CLAUDE.md
  2. A CLAUDE.md in each service's migrations folder
  3. A .claude/rules/ file with paths: ["**/migrations/**"]
  4. A /migration skill developers run
C. It loads for every migration file, wherever it is, and stays out of context otherwise. A works, but it loads for every file. B works, but there are many copies to keep in step. D works only when someone remembers to run it.

Mind map 2: Plan mode or just do it?

What you seeWhere the fault isFix
The change touches dozens of files, or needs a design decision (like service boundaries)Starting edits now risks reworkPlan mode: explore, then design, then change
There are several valid ways to do itClaude would pick one without comparingPlan mode
One clear fix in one place, like adding a single validation checkPlanning would only add timeDirect execution
Exploring the codebase floods the main context with search outputDiscovery runs in the main sessionUse the Explore subagent. It returns a summary
The question says the work is large from the start, and an option says “start direct, switch to plan if it gets complex”The complexity is already knownPlan mode now. “Switch later” is the trap
Rule: plan mode when the work is big, spans many files, or has a design choice. Direct execution when the change is small and its place is known. Use the Explore subagent to keep noisy discovery out of the main context.

Guide 3.4: “Plan mode: large-scale changes, multiple valid approaches, architectural decisions, multi-file mods. Direct execution: simple well-scoped changes (single validation check). Explore subagent isolates verbose discovery output, returns summaries.”

Example. A developer asks Claude Code to fix a typo in an error message. The file and line are named in the bug report. How should Claude work?
  1. Enter plan mode and design the fix first
  2. Make the change directly
  3. Send an Explore subagent to find related messages
  4. Ask Claude to interview the developer first
B. It's small and the place is known. A works, but it adds steps for no gain. C works, but nothing needs finding. D works, but there's nothing unclear to ask about.

Mind map 3: Claude keeps getting it wrong. How do you iterate?

What you seeWhere the fault isFix
A prose description of a transformation keeps being misreadWords are ambiguousGive 2 or 3 concrete input and output examples
You need proof the code behaves correctly“Looks right” isn't checkedWrite tests first, then share the failures with Claude
The task is in an unfamiliar area and the requirements aren't clearClaude would guess the missing partsThe interview pattern: Claude asks questions before building
Several problems affect each otherFixing them one by one undoes earlier fixesDescribe them all in one message
The problems are independentOne big message mixes themFix them one after another
Rule: show, don't describe (examples). Prove it (tests first). If you don't know what you want yet, let Claude ask (interview). Problems that affect each other go in one message; independent ones go one at a time.

Guide 3.5: “Concrete input/output examples communicate transformations better than prose. Test-driven iteration (write tests first, share failures); the interview pattern (Claude asks questions first); single message for interacting problems, sequential for independent ones.”

Example. A developer has twice described how log lines should be reformatted, and Claude's output is still wrong in a different way each time. What should they do next?
  1. Rewrite the description in more detail
  2. Show three real log lines and the exact output wanted for each
  3. Use the interview pattern
  4. Switch to plan mode
B. The words are being misread, so show examples. A works, but it's more of the same prose. C works when requirements are unclear, but here the developer knows exactly what they want. D is for big changes, not a format.

Mind map 4: Claude Code in CI

This is scenario 5. It mixes Domain 3 (the CLI) with Domain 4 (review quality).

What you seeWhere the fault isFix
The CI job hangs waiting for inputClaude Code is running interactivelyclaude -p "…" (or --print)
Findings must become inline PR commentsFree text can't be parsed reliably--output-format json with --json-schema
Reviews and generated tests ignore the project's standardsThe CI run has no project contextPut testing standards, fixtures and review criteria in CLAUDE.md
The session that wrote the code also reviews it, and misses bugsIt shares the reasoning that made the bugUse an independent review instance
Too many false positives, and developers stop trusting the reviewVague instructions like “be conservative”Explicit categorical criteria (what to flag, what to skip), with examples
A 14-file PR gets uneven, contradictory feedbackOne pass spreads attention too thinPer-file passes, then one cross-file pass
An overnight tech-debt report costs too muchIt runs in real time but nobody waits for itMessage Batches API (50% cheaper, up to 24 hours)
The check blocks a mergeBatch has no speed guaranteeKeep it real time, not batch
Rule: in CI, use -p and JSON output, give context through CLAUDE.md, review with a fresh instance, and cut false positives with explicit criteria. Use batch only when nobody is waiting.

Guide 3.6: “-p / --print = non-interactive mode. --output-format json + --json-schema for machine-parseable findings. The session that generated code is less effective at reviewing its own changes than an independent instance.” Guide 4.1: “‘Be conservative’ / ‘only high-confidence’ don't improve precision like categorical criteria.”

Example. A CI review flags many style nitpicks, and developers have started ignoring all of its comments, including real bugs. What should the team change first?
  1. Add “only report high-confidence issues” to the prompt
  2. List which issue types to report (bugs, security) and which to skip (style), with an example of each
  3. Run the review three times and keep issues found twice
  4. Use a larger model
B. Clear categories remove the noise. A works a little, but the guide says vague confidence words don't fix precision. C works, but it hides real bugs that show up only once. D doesn't address the unclear criteria.

Mind map 5: The session got long or stale

What you seeWhere the fault isFix
You want to carry on yesterday's conversationA new session starts empty--resume <session-name>
You want to try two approaches from the same starting pointOne session can only follow one pathfork_session
You resume after files were changed outside the sessionClaude still believes the old file contentsResume and tell Claude what changed
Most of the old tool results are now out of dateResuming brings back stale resultsStart a new session with a structured summary
The context is nearly full in a long sessionOld turns take up space/compact
Answers drift to “typical patterns” instead of what was found earlierThe context has degradedSave findings to a scratchpad file; hand verbose digging to subagents
A long multi-step job crashes halfway and has to start again from zeroProgress lives only in the conversationKeep a structured state file (a manifest) of what's done, and resume from it
Rule: resume to continue, fork to compare, start fresh with a summary when old results are stale. Use /compact for space, and a scratchpad file for findings that must survive.

Guide 1.7: “Starting a new session with a structured summary is more reliable than resuming with stale tool results.” Guide 5.4: “Scratchpad files persist key findings across boundaries; subagent delegation isolates verbose output. Structured state persistence (manifests) for crash recovery; /compact to reduce context usage.”

Example. A developer spent yesterday exploring a module with Claude. Overnight, a teammate refactored half of that module. Today the developer wants to continue. Best approach?
  1. --resume the session and carry on
  2. Start a new session with a short summary of yesterday's conclusions
  3. fork_session from yesterday's session
  4. Resume and run /compact
B. Half the old tool results are now wrong. A works if Claude is told what changed, but here too much changed. C keeps the same stale results. D shrinks the stale results but doesn't fix them.

Mind map 6: Which built-in tool?

This is mostly scenario 4 (developer productivity).

What you seeWhere the fault isFix
Find files by name, like every *.test.ts—Glob (file path patterns)
Find where a function is called—Grep (searches file contents)
Change one line in a file—Edit (matches a unique piece of text)
Edit fails because the text appears more than onceThe match isn't uniqueRead the file, then Write it back
Claude reads every file before starting, and the context fills upIt reads everything up frontGrep for the entry points, then Read along the imports
Claude uses Grep when a better MCP tool existsThe MCP tool's description is weakImprove the MCP tool's description (see MCP map 3)
Rule: Glob finds names, Grep finds contents, Edit makes small changes, and Read plus Write is the fallback. Build understanding step by step instead of reading everything.

Guide 2.5: “Grep = content search; Glob = file path patterns; Read/Write = full file ops; Edit = targeted change via unique text match. When Edit fails on non-unique match → Read + Write fallback. Build understanding incrementally: Grep entry points → Read to follow imports/trace flows.”

Example. A new developer asks Claude Code how a payment request flows through a large, unfamiliar repo. How should Claude start?
  1. Glob for every source file and Read them all
  2. Grep for the payment entry point, then Read the files it imports, one by one
  3. Read the README and answer from it
  4. Ask the developer which files matter
B. It follows the real path and keeps the context small. A works on a tiny repo, but here it floods the context. C works for an overview, but the README may not match the code. D works, but a new developer doesn't know.

Three traps that catch people

1 · Personal file or project file?

If the question says “every developer”, “on clone” or “new team member”, the answer is in the repo: project CLAUDE.md, .claude/commands/, .claude/rules/ or .mcp.json. Anything under ~/ is only for you.

2 · Directory CLAUDE.md or a rules file?

If the files sit in one folder, a directory CLAUDE.md works. If they're spread across folders but share a name pattern (tests, migrations), a .claude/rules/ file with paths: wins.

3 · Commands: the exam's answer vs today

Today's Claude Code merges commands into skills, but the guide still teaches .claude/commands/ for a shared slash command. On the exam, follow the guide. More on Exam vs 2026.

How to study this

  1. Read one mind map, then open its Trap Gym page. Change the setting and watch what happens.
  2. Do the D3 practice questions. For each one, say which row of which map decides it.
  3. Print this page and cover the Fix column. Can you fill it in from memory?

Related: Domain 3 hub · Claude Code lab · MCP mind maps · Exam vs 2026 · all traps · CCA-F start here