Free CCDV-F Claude Code Practice Test — Claude Certified Developer Questions

This free CCDV-F Claude Code practice test covers using Claude Code for agentic software development — the CLI, CLAUDE.md project configuration, hooks, slash commands, permissions, and headless automation. Each question includes a detailed explanation aligned to Anthropic's official Claude Certified Developer – Foundations exam outline.

Key Topics in CCDV-F Claude Code

6 Free CCDV-F Claude Code Practice Questions with Answers

Each question below includes 4 answer options, the correct answer, and a detailed explanation. These are real questions from the FlashGenius CCDV-F question bank for the Claude Code domain (3.1% of the exam).

Sample Question 1 — Claude Code

A team repeatedly tells Claude Code the same repository conventions at the start of every session. They want the guidance to be durable, reviewable, and reused by all contributors. Current onboarding note: ``` Before using Claude Code, paste: - Use pytest for backend tests. - Prefer existing repository helpers over new utilities. - Follow the service naming pattern in /services. ``` What is the BEST primary change?

  1. A. Move the conventions into a repository CLAUDE.md file. (Correct answer)
  2. B. Store the conventions in Agent Memory for each developer.
  3. C. Add the conventions as comments in settings.json.
  4. D. Paste the conventions into every new session prompt.

Correct answer: A

Explanation: Correct answer (A): CLAUDE.md is the appropriate Claude Code mechanism for durable, human-readable project or repository instructions. It avoids repeated ad hoc prompting and makes conventions easier for the team to review and maintain across sessions and contributors. Why the other options are wrong: - Option B: Agent Memory can retain context or preferences, but shared project conventions should be explicit and reviewable in repository guidance rather than hidden per developer. - Option C: settings.json is for Claude Code configuration, not for storing human-readable coding standards as comments or policy guidance. - Option D: Repeating the guidance manually is exactly the brittle workflow the team is trying to eliminate.

Sample Question 2 — Claude Code

A monorepo uses Claude Code across frontend and backend teams. Repository layout: ``` /CLAUDE.md "All code must use the shared logging wrapper." /web/CLAUDE.md "Use the design-system components for UI work." /api/ payment handlers, database migrations, service tests ``` The API team wants Claude Code to consistently follow API-only conventions for migrations and service tests without affecting web work. Where should the team place this guidance?

  1. A. In a new /api/CLAUDE.md file near the API code. (Correct answer)
  2. B. In /web/CLAUDE.md so all nested teams can see it.
  3. C. In Agent Memory for the API team's lead developer.
  4. D. In settings.json as a repository-wide configuration value.

Correct answer: A

Explanation: Correct answer (A): A CLAUDE.md hierarchy lets teams place broad guidance at the repository root and narrower guidance closer to the subdirectory it governs. API-specific conventions belong near the API code so they apply to that scope without polluting unrelated web guidance. Why the other options are wrong: - Option B: The web CLAUDE.md is scoped to frontend work and is the wrong location for API-only guidance. - Option C: Agent Memory is not the best place for shared API project policy because it is not explicit repository guidance for all contributors. - Option D: settings.json configures Claude Code behavior, but coding conventions for a subdirectory belong in human-readable CLAUDE.md guidance.

Sample Question 3 — Claude Code

A developer is cleaning up a Claude Code repository setup. Current file: ``` // settings.json { "team_note": "When editing billing code, preserve the audit-log helper and add tests." } ``` The team wants this instruction to be visible as project guidance rather than treated like tool configuration. What should the developer do?

  1. A. Move the note into the relevant CLAUDE.md guidance. (Correct answer)
  2. B. Rename team_note to project_rule in settings.json.
  3. C. Convert the note into a custom slash command.
  4. D. Store the note only in the developer's session history.

Correct answer: A

Explanation: Correct answer (A): settings.json is the place for Claude Code configuration, while CLAUDE.md is better suited for human-readable project guidance and development conventions. The instruction describes how to work on billing code, not a Claude Code configuration setting. Why the other options are wrong: - Option B: Renaming the key does not change the fact that settings.json is the wrong place for project coding guidance. - Option C: A custom slash command is useful for repeatable invocations, but this is persistent guidance that should apply whenever relevant code is edited. - Option D: Session history is not durable, reviewable team guidance and will not reliably help other contributors.

Sample Question 4 — Claude Code

A team asks Claude Code to perform the same release-prep workflow several times per week. Current checklist pasted into chat: ``` 1. Read CHANGELOG.md and summarize unreleased changes. 2. Check package version files for consistency. 3. Draft the release-note PR description. ``` They want a repeatable project-specific invocation rather than copying this checklist each time. What is the BEST fit?

  1. A. Create a custom slash command for the release-prep workflow. (Correct answer)
  2. B. Move the checklist into Agent Memory for the release manager.
  3. C. Put the checklist in settings.json under a workflow key.
  4. D. Use a new nested CLAUDE.md as the only change.

Correct answer: A

Explanation: Correct answer (A): Custom slash commands are appropriate when a team needs a repeatable project-specific Claude Code workflow. The checklist is an invocation the team wants to run on demand, not a persistent coding policy or a personal memory. Why the other options are wrong: - Option B: Agent Memory may retain preferences, but it is not the best mechanism for a shared on-demand workflow that multiple contributors need to invoke consistently. - Option C: settings.json is for configuration, not for defining a user-facing repeatable project workflow checklist. - Option D: CLAUDE.md can document conventions, but by itself it does not provide the clean repeatable invocation the team requested.

Sample Question 5 — Claude Code

A senior developer wants Claude Code to remember a repository rule for all future contributors. Proposed note: ``` Always use the repository's generated API client. Do not hand-write HTTP wrappers in product code. This rule should be reviewed in pull requests when it changes. ``` What is the MOST appropriate place for this rule?

  1. A. A versioned CLAUDE.md file at the appropriate repository scope. (Correct answer)
  2. B. Agent Memory for the senior developer's local Claude Code use.
  3. C. A custom slash command named for API client generation.
  4. D. The transcript of a long-running Claude Code session.

Correct answer: A

Explanation: Correct answer (A): Because the rule is shared project policy and must be reviewable when it changes, it belongs in explicit repository guidance such as CLAUDE.md. Agent Memory is better for retained context or preferences, not team-wide coding standards that must be visible and maintainable. Why the other options are wrong: - Option B: Agent Memory may help with personal retained context, but it is not the best place for project policy that all contributors must see and review. - Option C: A custom slash command could run a workflow, but the stated need is a persistent rule that should guide product code changes. - Option D: A session transcript is neither a maintainable policy location nor a reliable way to guide future contributors.

Sample Question 6 — Claude Code

A platform team wants to run Claude Code from a nightly automation job. Requirement excerpt: ``` - No developer will be present during execution. - The job should analyze changed files and produce a summary artifact. - Interactive chat prompts should not be required. ``` Which Claude Code operating pattern is the BEST fit?

  1. A. Run Claude Code in headless mode for the job. (Correct answer)
  2. B. Require an interactive Claude Code session overnight.
  3. C. Store the job instructions only in Agent Memory.
  4. D. Replace the workflow with a nested CLAUDE.md file.

Correct answer: A

Explanation: Correct answer (A): Headless mode is appropriate for non-interactive or automation-oriented Claude Code execution where no developer needs an interactive chat session. The requirement explicitly calls for unattended operation that produces an artifact. Why the other options are wrong: - Option B: An interactive session conflicts with the requirement that no developer be present and no chat prompts be required. - Option C: Agent Memory does not define the operating mode for unattended automation and would not by itself run the job. - Option D: A nested CLAUDE.md may provide guidance, but it does not replace the need for a non-interactive execution pattern.

How to Study CCDV-F Claude Code

Combine these CCDV-F Claude Code practice questions with the official Anthropic documentation and hands-on projects. Build a small Claude-powered application with tool use, try Claude Code on a real repository, and iterate on prompts with evals — practical experience is the fastest way to master this domain.

About the CCDV-F Exam

Other CCDV-F Domains

Start the free CCDV-F Claude Code practice test now | 10-question quick start | All CCDV-F domains