Claude Code Configuration: Master Domain 3 for CCA-F

Domain 3 of the Claude Certified Architect, Foundations exam covers claude code configuration and workflows, and it carries a 20% weight, making it one of the four heaviest domains on the 60-question paper. If you are preparing for the CCA-F, this domain rewards engineers who understand how Claude Code is configured at multiple scopes, how those scopes interact, and how automated workflows are composed from that configuration. This post maps the domain systematically so you know exactly what to study.

What does Domain 3 actually test?

Domain 3 tests your ability to configure Claude Code correctly across different deployment contexts and to design workflows that are reproducible, version-controlled, and team-safe. Per Anthropic's exam guide, the domain sits alongside Prompt Engineering and Structured Output (also 20%) as a mid-weight area. The exam does not test trivia about flag names in isolation; it tests whether you can reason about which configuration scope to use, why, and what breaks when you choose the wrong one.

The five domain weights are worth keeping in front of you throughout your preparation:

Domain 3 is not the heaviest, but a 20% domain that you under-prepare for costs you roughly 12 questions, which is enough to move a borderline candidate from a pass to a fail at the 720 scaled-score threshold.

What is the three-level configuration hierarchy?

The three-level configuration hierarchy is the structural backbone of Domain 3. Claude Code resolves configuration at three scopes: enterprise (system-level), project (repository-level), and personal (user-level). Each scope has a defined precedence, and the exam tests candidates on what happens at the boundaries.

Our Three-Level Configuration Hierarchy concept page covers this in full, but the practical summary is:

1. Enterprise scope is set by administrators and cannot be overridden by lower scopes. It is appropriate for compliance requirements, approved model lists, and network proxy settings.
2. Project scope lives in the repository, typically in a CLAUDE.md file or .claude/ directory. It travels with the codebase and applies to every team member who clones it.
3. Personal scope is stored in the user's home directory. It is appropriate for individual preferences such as editor integration or personal API key routing, but it must never carry secrets that belong to the team.

The exam consistently rewards answers that place configuration at the lowest scope that satisfies the requirement. Putting a compliance rule in personal scope is wrong; putting a personal editor preference in enterprise scope is also wrong. Proportionate placement is the pattern.

How does CLAUDE.md work and why does it matter for teams?

CLAUDE.md is a markdown file placed at the root of a repository (or within subdirectories for path-scoped rules) that Claude Code reads as persistent project context. It is the primary mechanism for encoding project conventions, architectural constraints, and workflow instructions that should apply to every session a team member opens against that codebase.

A minimal but well-structured CLAUDE.md might look like this:

# Project: Payments Service

## Architecture conventions
- All external API calls go through `src/clients/`. Never call third-party APIs directly from handlers.
- Use structured logging via `logger.info({event, payload})`. No `console.log` in production paths.

## Testing
- Unit tests live in `__tests__/` adjacent to the module they test.
- Run `npm test -- --coverage` before committing. Coverage must not drop below 80%.

## Claude Code behaviour
- Do not modify `src/generated/` files. These are auto-generated from the OpenAPI spec.
- When suggesting refactors, prefer incremental changes over full rewrites.

The exam tests whether candidates understand that CLAUDE.md is version-controlled and therefore subject to the same review process as code. A change to CLAUDE.md that relaxes a constraint is a change that affects every engineer on the team. This is not a configuration file to edit casually.

Version control implications for CLAUDE.md are a distinct concept the exam probes. The key principle: because CLAUDE.md is committed to the repository, it inherits all the governance properties of source code, including code review, audit history, and branch protection rules.

How do path-scoped rules change behaviour in large codebases?

In a monorepo or a codebase with distinct subsystems, a single root-level CLAUDE.md can become unwieldy. Claude Code supports path-scoped CLAUDE.md files placed in subdirectories. When Claude Code operates on a file, it reads the CLAUDE.md files from the root down to the file's directory, merging them in order of specificity.

This matters for the exam in two ways. First, more specific rules override less specific ones, so a subdirectory CLAUDE.md can tighten (but should not silently contradict) a root-level rule. Second, the exam tests candidates on diagnosing misconfiguration: if a rule appears to have no effect, the first diagnostic step is to check whether a more specific CLAUDE.md is overriding it.

A common exam scenario: a root CLAUDE.md forbids direct database queries outside the src/db/ module, but a subdirectory CLAUDE.md for a legacy service does not repeat this constraint. The question asks what Claude Code will do when operating on files in that subdirectory. The answer is that the root constraint still applies unless the subdirectory file explicitly overrides it, because the merge is additive by default.

What workflow automation patterns does Domain 3 cover?

Beyond configuration files, Domain 3 covers how Claude Code is integrated into automated workflows, including CI/CD pipelines, pre-commit hooks, and non-interactive batch operations. The exam tests the -p flag (non-interactive mode), structured output from CI runs, and how to design workflows that are deterministic enough to run unattended.

A representative CI workflow using the -p flag looks like this:

# Run Claude Code in non-interactive mode to generate a test coverage report
claude -p "Review the diff in this PR and identify any functions that lack unit tests. Output a JSON array of {file, function, reason} objects." \
  --output-format json \
  > coverage-gaps.json

The exam does not ask you to memorise flag syntax verbatim, but it does ask you to reason about when non-interactive mode is appropriate versus when an interactive session is required. The rule of thumb the exam rewards: non-interactive mode is correct when the task is well-specified, the output format is deterministic, and no human judgement is needed mid-task. If any of those conditions fail, an interactive session or a human-in-the-loop checkpoint is the right answer.

For teams building CI pipelines around Claude Code, structured JSON output is the preferred format because it is parseable by downstream tools without brittle string matching. Our Claude Code Configuration & Workflows concept domain covers the full set of patterns the exam draws from.

How do skills and commands extend Claude Code for teams?

Claude Code supports two extension mechanisms that Domain 3 tests: skills (reusable prompt templates stored as .md files in a .claude/skills/ directory) and slash commands (shortcuts that invoke those skills or other predefined prompts). Together they allow teams to encode institutional knowledge into Claude Code in a way that is discoverable, version-controlled, and consistent across engineers.

The distinction the exam draws is between skills and CLAUDE.md entries. A CLAUDE.md entry is always active context; a skill is invoked on demand. Use CLAUDE.md for constraints and conventions that should apply to every interaction. Use skills for complex, multi-step tasks that engineers invoke occasionally, such as generating a migration script or producing a release notes draft.

.claude/
  skills/
    generate-migration.md
    draft-release-notes.md
    review-security.md
  commands/
    /migration -> generate-migration.md
    /release   -> draft-release-notes.md
    /sec-review -> review-security.md

The exam tests whether candidates can identify when a skill should be split (because it is trying to do two distinct things) versus when it should be merged (because two skills always run together and splitting them creates coordination overhead). This mirrors the tool splitting for specificity principle from Domain 2, applied to the configuration layer.

How does Domain 3 connect to agentic workflows?

Domain 3 does not exist in isolation. The exam frequently presents scenarios that span Domain 3 (configuration) and Domain 1 (agentic architecture). A well-configured Claude Code environment is a prerequisite for reliable agentic workflows: if the project-level CLAUDE.md does not encode the right constraints, a subagent operating autonomously may violate architectural conventions that a human engineer would have caught interactively.

The connection runs in the other direction too. Agentic loop anti-patterns often trace back to configuration failures: a missing constraint in CLAUDE.md allows Claude Code to take an action that the loop was not designed to handle, causing the agent to stall or produce incorrect output. Diagnosing these failures requires understanding both the agentic architecture and the configuration layer.

This cross-domain reasoning is exactly what the CCA-F exam is designed to test. The 60 scenario-based questions are not isolated knowledge checks; they are situations that require you to reason across domains. A candidate who has memorised Domain 3 facts but cannot connect them to Domain 1 agentic patterns will struggle with the multi-domain scenarios that appear throughout the paper.

How should you prepare for Domain 3 specifically?

Preparation for Domain 3 should be hands-on wherever possible. Reading about the three-level hierarchy is useful; actually creating a CLAUDE.md file, testing path-scoped overrides, and running Claude Code in non-interactive mode against a real codebase is more useful. The exam rewards candidates who have encountered the failure modes, not just the happy paths.

For structured concept review, our Claude Code Configuration & Workflows section maps all 174 atomic concepts in our library to the five exam domains. Domain 3 concepts include the three-level hierarchy, version control implications, path-scoped rules, CI/CD integration patterns, and the skills-versus-CLAUDE.md distinction.

For practice under exam conditions, our adaptive engine uses Bayesian Knowledge Tracing with a 0.90 mastery threshold. It will not mark you ready on a Domain 3 concept until you have demonstrated consistent correct reasoning across multiple scenario variants, not just a single correct answer. Practice exams are 60 questions, scored on the same 100 to 1000 scale as the real exam, with 720 as the passing bar. (AI Skill Certs is an independent prep platform; we are not affiliated with or endorsed by Anthropic.)

The CCA-F launched on 12 March 2026 at $99 per attempt. As of 3 June 2026, more than 10,000 individuals have earned the certification. With further architect, developer, and seller certifications planned for later in 2026, the CCA-F is the foundation credential in what Anthropic is building into a full certification programme. Getting Domain 3 right is not just about passing this exam; it is about building the configuration discipline that every subsequent Claude-based role will assume you have.