Home/Practice Test/Claude/Free CCDV-F Practice Test 2026 | Claude Developer Foundations 80+ Questions

Free CCDV-F Practice Test 2026 | Claude Developer Foundations 80+ Questions

Put your Claude development skills to work. Take the free CCDV-F practice test and find out how ready you are to build and ship reliable AI applications.

Real Exam Style
Questions
Detailed
Explanations
All Domains
Covered
Timed
Practice
4.8919 learner reviews across Microsoft, AWS, and CompTIA tracksVerified purchases
Jump Straight to the Free CCDV-F Questions (No Sign-Up or Credit Card required)
Why choose us
1
Expert Explanations + Sources Master every concept with clarity.
2
2026-Fresh Questions Always current, never outdated.
3
Real Exam Simulation Practice like you'll test.
4
90-Day Free Updates Stay ahead of changes.
5
Start in 60 Seconds No waiting, instant access.

CCDV-F exam at a glance

Claude Certified Developer – Foundations · Foundations level

Exam codeCCDV-F
CertificationClaude Certified Developer – Foundations
LevelFoundations
Number of questions53
Duration120 minutes
Passing score720 on a scaled score of 100–1,000
Question formatsMultiple choice and scenario-based multiple response
DeliveryOnline proctored or at a Pearson test center
Exam cost$125 USD before applicable partner-tier discounts
LanguagesEnglish
Certification validity12 months from the date earned
PrerequisitesNo formal prerequisite

For technical professionals who build, integrate, and ship production applications, agents, and workflows on the Claude platform.

Skills measured and their weighting

Skill areaWeight
Applications and Integration33.1%
Model Selection and Optimization16.8%
Agents and Workflows14.7%
Prompt and Context Engineering11.0%
Tools and MCPs10.6%
Security and Safety8.1%
Claude Code3.1%
Eval, Testing, and Debugging2.6%

Source: anthropic-partners.skilljar.com — official Claude Certified Developer – Foundations certification page. Figures were checked against Anthropic’s official certification documentation. Confirm current details there before booking.

Sit the whole exam before you sit the whole exam

The full bank covers every domain, with timed mode and per-domain scoring.

Premium
Timed mode Per-domain score tracking Unlimited free updates PDF + Practice Test
Get the full bank 30-day money back

CCDV-F Practice Questions By Domains

8 domains covered
Premium 30 of 82 free

Practice the full exam, not a sample

Unlock the full bank and practise every domain end to end.

Unlock all 82 questions

Claude Certified Developer – Foundations (CCDV-F) Practice Test

The Claude Certified Developer – Foundations practice test helps developers measure whether they can build reliable Claude-powered applications, agents, tools, and integrations—not merely send a basic prompt to an API. Strong preparation connects product knowledge with practical software decisions involving requirements, architecture, context, security, testing, cost, and deployment. You can Explore online practice exams by category while using this guide to organize your learning around Anthropic’s official CCDV-F domains.

Anthropic positions CCDV-F as the technical builder credential in its certification program. The official credential description says successful candidates can build, integrate, and ship production applications and agents using the Claude API, Claude Code, custom tools, and Model Context Protocol servers. This makes the certification relevant to developers who want to move beyond experimental prompts and understand how Claude applications behave when real users depend on them.

This guide explains the official domain structure in student-friendly language, identifies the skills a useful mock assessment should test, and provides a practical preparation framework. It does not contain copied, protected, or live certification questions. Use original exam-style practice alongside Anthropic’s current exam guide, preparation course, developer documentation, and hands-on projects.

What Is a CCDV-F Practice Test?

A CCDV-F practice test is a learning assessment aligned with the Claude Certified Developer – Foundations blueprint. It should test applied development judgment through short technical scenarios.

A useful question may ask you to:

  • select an agent or workflow pattern for a requirement;
  • use the Claude API or an SDK correctly;
  • design streaming or asynchronous application behavior;
  • define a tool schema that Claude can use reliably;
  • manage context, memory, and long-running tasks;
  • select a suitable model and control token costs;
  • configure Claude Code for a development team;
  • diagnose API, tool, or output failures;
  • protect credentials and enforce authorization;
  • build an MCP server with appropriate scope and controls.

Effective practice questions should include explanations for every option. The explanation should identify the requirement that controls the answer, show why the preferred approach works, and clarify why other choices are incomplete or unnecessarily risky.

Who Should Prepare for CCDV-F?

The certification is intended for hands-on developers building and shipping Claude-based applications. It is especially useful for:

  • software developers working in Python or TypeScript;
  • AI application developers;
  • engineers integrating Claude through REST APIs or SDKs;
  • developers building agent loops and tool-enabled workflows;
  • teams using Claude Code in daily software work;
  • engineers creating MCP servers;
  • developers responsible for evaluation, security, cost, and production reliability.

You do not need to be an advanced machine-learning researcher. However, you should understand common software-engineering concepts, API requests and responses, command-line tools, configuration, source control, error handling, testing, and secure credential management. The exam focuses on building with Claude, so hands-on development is more useful than memorizing terminology alone.

Official CCDV-F Domains and Weightings

Anthropic’s CCDV-F blueprint contains eight domains. The published weights are unusually detailed and show that practical application development receives the greatest emphasis.

The percentages total 100%. Applications and Integration alone represent about one-third of the blueprint, so practice sets should give it noticeably more coverage than smaller areas such as Claude Code or debugging. Smaller does not mean optional: questions from every domain can influence your overall result.

Domain 1: Agents and Workflows (14.7%)

This domain focuses on systems that perform more than a single model call. You should understand when a defined workflow is enough, when an agent is justified, and how to keep agent behavior observable and controlled.

Compare workflows and agents

A workflow follows known steps. It is often easier to test, predict, and maintain. An agent chooses actions dynamically according to its goal, available tools, and intermediate results. Agents are helpful when the exact path cannot be fully defined in advance, but they introduce additional risk and complexity.

Do not select an agent merely because it sounds modern. Use the simplest pattern that meets the requirement. A fixed classification-and-routing process may need a workflow, while a research task that must choose sources and revise its plan may justify an agent.

Build a controlled agent loop

A basic loop gives the model a goal and available tools, receives a requested action, executes an approved tool, returns the result, and continues until a stopping condition is reached. A reliable implementation also needs:

  • clear goals and boundaries;
  • validated tool inputs;
  • limits on steps, time, or spending;
  • handling for failed tool calls;
  • state management;
  • human approval for sensitive actions;
  • logging and traceability;
  • a safe completion or cancellation path.

Use common patterns thoughtfully

Patterns may include routing, parallel work, sequential processing, evaluator-improver loops, and manager-worker designs. Each pattern has trade-offs. Parallel work can improve speed but complicates result combination. An evaluator loop may improve quality but increases cost and latency. Multi-agent designs should represent real separation of responsibilities, context, or permissions.

Practise failure scenarios

Good mock questions should include an agent that repeats actions, selects the wrong tool, loses state, exceeds a budget, or tries to complete a sensitive action without approval. The best answer usually improves the control at the correct layer instead of adding a vague instruction such as “be more careful.”

Domain 2: Applications and Integration (33.1%)

This is the largest CCDV-F domain. It covers how developers turn requirements into maintainable Claude applications and connect those applications to production systems.

Understand requirements before coding

Identify users, desired outcomes, input types, output requirements, integrations, security limits, quality expectations, latency needs, and operating cost. If an AI feature does not provide clear value, a normal deterministic component may be better.

A practice scenario may include an unclear request for “an intelligent assistant.” Before implementation, the developer should clarify what tasks it performs, what information it can access, what actions it may take, and how success will be measured.

Work with Claude API mechanics

You should understand the structure of requests and responses, authentication, roles, content blocks, model parameters, token limits, streaming, and error responses. Learn when an official SDK provides convenience and when direct REST interaction may be appropriate.

Production code should not assume every response is immediate or successful. Handle rate limits, timeouts, transient failures, malformed outputs, and network interruptions. Retrying can help with temporary failures, but retries should use limits and backoff so the application does not increase the problem.

Design for streaming and asynchronous work

Streaming can improve user experience by displaying output as it becomes available. The application must still handle interrupted streams, partial content, cancellation, and the final completion state.

Longer work may be better handled asynchronously. Users should receive a clear task status rather than hold an unreliable connection open. The design should define where progress, results, failures, and retries are stored.

Apply software-engineering foundations

Separate Claude-specific logic from business rules and external integrations. Use small components, clear interfaces, configuration outside source code, testable functions, structured logging, and version control.

Deterministic rules should remain deterministic. Do not ask a model to perform simple validation or authorization that ordinary code can enforce more reliably.

Manage the application lifecycle

Building the first demonstration is only one step. A production lifecycle includes discovery, design, implementation, evaluation, security review, deployment, monitoring, maintenance, and retirement. Model, prompt, tool, and data changes should follow controlled release practices.

Control configuration

Keep environment-specific values outside the code. Separate development, testing, and production settings. Validate configuration at startup and provide safe defaults only where they make sense. Credentials should use a secure secret-management method rather than source files.

After reviewing the largest domain, you can Prepare for another Claude certification and compare practice options across the Claude credential family.

Domain 3: Claude Code (3.1%)

Claude Code supports software work in a codebase, but effective use requires clear scope, review, and verification.

Use a disciplined working loop

A helpful approach is to explore the repository, plan the change, implement it, and verify the result. Ask Claude Code to identify relevant files and dependencies before making a broad change. For complex work, review the proposed plan before allowing edits.

Provide durable project guidance

Project instructions can describe commands, architecture, conventions, testing expectations, and areas that require caution. Keep them current and concise. Conflicting or outdated guidance can be worse than no guidance.

Control permissions

Developers should understand what actions Claude Code can take and when approval is required. High-impact or irreversible actions deserve stronger review. The model should not receive broad access simply for convenience.

Verify generated changes

Review diffs, run tests, apply linters or type checks, and confirm that the change meets the requirement. Claude Code accelerates development but does not remove developer accountability.

Domain 4: Eval, Testing, and Debugging (2.6%)

Although this is the smallest domain, evaluation and debugging affect every production application.

Separate failure types

When output is wrong, determine whether the cause is:

  • an unclear requirement;
  • a weak prompt;
  • missing or excessive context;
  • incorrect retrieval;
  • a bad tool schema;
  • application logic;
  • an API or network failure;
  • model limitations;
  • invalid output handling.

Changing the model will not fix a broken authorization check or incorrect business rule.

Test at several levels

Use unit tests for deterministic helpers, contract tests for integrations, tool tests for schemas and execution, evaluation sets for model behavior, and end-to-end tests for the complete user flow.

Build representative evaluations

Include ordinary inputs, edge cases, known failures, ambiguous requests, and unsafe or unauthorized attempts. Define expected behavior before judging results.

Improve observability

Record request identifiers, latency, token usage, tool calls, errors, and relevant application decisions while protecting sensitive data. Structured information helps developers reproduce and diagnose failures.

Domain 5: Model Selection and Optimisation (16.8%)

This is the second-largest domain. It covers how language models behave, how applications call them, and how developers balance quality, speed, and cost.

Understand probabilistic behavior

Language models generate likely outputs rather than retrieving guaranteed truth. The same instruction can produce variations. Applications should use validation, grounding, deterministic constraints, or human review according to the risk of error.

Select models by workload

Consider task complexity, accuracy needs, latency, cost, context length, tool-use requirements, and expected volume. A demanding planning task and a high-volume extraction task may use different configurations.

Do not memorize a temporary model chart as your only preparation. Model families change. Learn the decision method and review current Anthropic documentation before the exam.

Manage tokens and context

Tokens affect context capacity, latency, and cost. Avoid repeatedly sending material that does not influence the answer. Use retrieval, summarization, state management, or caching when appropriate.

Apply caching and batching appropriately

Stable repeated content may benefit from prompt caching. Independent high-volume tasks may benefit from batch processing. Evaluate whether the workload can tolerate delayed results and whether the repeated prefix is stable enough to justify caching.

Optimize against a baseline

Measure quality, latency, token use, and cost before making changes. A cheaper configuration is not an improvement if task completion falls below the required level. Likewise, a small quality gain may not justify a large latency increase for an interactive feature.

Handle rate and capacity limits

Production applications should anticipate rate limits, use controlled concurrency, and apply suitable backoff. Queueing and workload shaping can prevent bursts from overwhelming the service.

Domain 6: Prompt and Context Engineering (11%)

This domain examines how developers provide instructions and information so Claude can perform reliably.

Write clear prompts

Define the task, inputs, expected output, constraints, and success criteria. Separate instructions from user-provided data so the application can handle both consistently.

Useful prompts may specify:

  • role or responsibility where helpful;
  • permitted sources or tools;
  • output schema;
  • rules for missing information;
  • examples of correct format;
  • boundaries and prohibited actions.

Manage context intentionally

Context engineering includes deciding what information Claude sees and when. Stable instructions, conversation history, retrieved knowledge, tool definitions, tool results, and working state all compete for attention and tokens.

Use progressive access when the full information set is large. Retrieve or load what is relevant to the current step rather than placing every possible document or tool definition in every request.

Handle structured outputs

If downstream code needs fields, request a clear schema and validate the result. Never assume that model-generated JSON or another format is automatically safe or complete. Check types, required properties, allowed values, and size limits before use.

Defend against instruction conflicts

External documents and tool outputs may contain text that looks like instructions. Treat untrusted content as data. Important authorization and security rules should be enforced by the application, not only stated in a prompt.

For broader study support, Discover learning tools for certification candidates while continuing to use Anthropic’s official guide and developer documentation as primary references.

Domain 7: Security and Safety (8.1%)

Claude applications introduce familiar software risks as well as risks related to untrusted instructions, powerful tools, and generated output.

Protect identity, secrets, and keys

Never embed API keys in public code or client-side applications. Use secure secret storage, rotate credentials, and grant the minimum permissions required. Associate user actions with the correct identity rather than allowing every request to operate under one broad service account.

Enforce authorization outside the model

Claude can help decide what action to request, but trusted code must decide whether that action is permitted. Validate every tool call and check the user’s authorization before reading data or performing a change.

Reduce prompt-injection risk

Assume external content may contain malicious instructions. Separate trusted instructions from untrusted data, restrict tools, validate actions, filter or isolate content where appropriate, and require approval for high-impact operations.

Use layered guardrails

Safety may include input checks, tool constraints, output validation, human review, monitoring, and incident response. A single prompt rule is not a complete security design.

Apply hooks responsibly

Hooks can automate deterministic checks or actions around development and agent workflows. Because they can execute powerful operations, review their source, scope, environment, failure behavior, and permissions.

Plan for safe failure

Decide what happens when validation, moderation, retrieval, or a tool is unavailable. For sensitive workflows, stopping or escalating may be safer than silently continuing.

Domain 8: Tools and MCPs (10.6%)

Tools let Claude interact with application capabilities, while Model Context Protocol provides a standard way to expose tools and resources.

Design usable tool schemas

Tool names and descriptions should clearly communicate purpose. Input schemas should use suitable types, required fields, descriptions, and constraints. Avoid overlapping tools that make selection unnecessarily difficult.

The application should validate inputs again before execution. A valid schema does not prove that the requested action is authorized or sensible.

Return useful tool results

Tool responses should provide the information Claude needs without unnecessary volume. Clearly distinguish success, failure, partial results, and retryable errors. Avoid returning sensitive fields that are not needed for the next step.

Build MCP servers with limited scope

An MCP server can expose tools, resources, and prompts. Keep its capabilities focused, document configuration, and use secure transport and authentication suitable for the deployment.

Understand scope and configuration

Configuration may apply at different levels, such as one project, one user, or a wider environment. Select a scope that supports collaboration without exposing credentials or tools more broadly than intended.

Secure tool access

Tool discovery does not equal permission. Enforce identity and authorization at execution time. High-impact tools may require confirmation, approval, or a separate restricted service.

Customize agents thoughtfully

Skills, commands, rules, subagents, and tool sets can make workflows reusable. Each addition should have a clear purpose. Too many overlapping capabilities can increase cost, confusion, and the chance of an incorrect action.

How to Use CCDV-F Practice Tests Effectively

Start with a mixed diagnostic assessment. Track results by domain rather than focusing only on a total score. The domain weights show that weak performance in Applications and Integration or Model Selection deserves significant attention.

Use this study cycle:

  1. Review one official objective area.
  2. Build or inspect a small working example.
  3. Answer a short practice set.
  4. Review every explanation.
  5. Record the reason for each mistake.
  6. Change the scenario and solve it again.

Classify mistakes with a simple table:

Mistake typeLikely causeUseful next action
API mistakeRequest, response, streaming, or error behavior is unclearBuild a small API example and inspect raw responses
Design mistakeThe pattern is too simple or too complexCompare single calls, workflows, and agents
Context mistakeClaude received missing or noisy informationMap stable, retrieved, and step-specific context
Security mistakeThe model was trusted to enforce accessMove authorization and validation into trusted code
Tool mistakeSchema, description, or execution behavior is weakRedesign the tool contract and test edge cases
Optimisation mistakeCost or speed changed without quality evidenceEstablish a baseline and repeat evaluations

After domain review, complete mixed timed sessions without documentation. Practise both multiple-choice and multiple-response questions. Read the requirement before the code or answer options, then identify the decisive constraint.

What You Get When You Prepare With Us

A useful CCDV-F preparation experience should help you connect technical concepts to working development decisions. It should provide:

  • Official-domain alignment: Practice structured around all eight Anthropic blueprint domains.
  • Weight-aware coverage: Extra focus on Applications and Integration, Model Selection, and Agents and Workflows.
  • Original technical scenarios: Questions designed for learning without claiming to reproduce protected certification content.
  • Clear explanations: Plain-language reasoning for the correct and incorrect options.
  • Focused practice sets: Targeted review for APIs, agents, Claude Code, context, security, tools, and MCP.
  • Mixed readiness assessments: Broader sessions that test several skills together.
  • Progress awareness: Domain scores and error categories that identify where further study is needed.
  • Practical learning: Guidance that encourages small builds, debugging, evaluation, and secure implementation.

The aim is to develop transferable skill. A candidate should be able to explain not only what to implement but why the design is reliable, secure, maintainable, and appropriate for the workload.

A Six-Week CCDV-F Study Plan

Week 1: API and application foundations

Build a small application using an official SDK or REST API. Review requests, responses, authentication, streaming, errors, retries, configuration, and logging.

Week 2: Agents and workflows

Compare direct model calls, fixed workflows, and agent loops. Implement a tool-using loop with step limits, failure handling, and approval for a sensitive action.

Week 3: Models, tokens, and performance

Study model-selection trade-offs, context limits, token use, caching, batching, concurrency, latency, and cost. Measure a small baseline before making improvements.

Week 4: Prompts, context, and structured output

Version prompts, create representative examples, manage retrieved context, and validate structured outputs. Test how the application handles missing or malicious input.

Week 5: Tools, MCP, and security

Design several clear tool schemas and build or inspect an MCP server. Review configuration scope, identity, secrets, authorization, prompt injection, guardrails, and hooks.

Week 6: Claude Code, evaluation, and mixed review

Use Claude Code on a controlled repository task, review every change, and run tests. Complete mixed practice assessments and revisit weak domains through changed scenarios.

Common CCDV-F Preparation Mistakes

Memorizing code without understanding behavior

SDK syntax may change. Understand request structure, streaming, tool calls, errors, and application responsibilities.

Building an agent when a workflow is enough

Unnecessary autonomy makes testing, security, and cost management harder. Select the simplest suitable pattern.

Relying on prompts for security

Prompts can guide behavior but cannot replace authentication, authorization, input validation, secret management, and restricted tool execution.

Ignoring the largest domain

Applications and Integration represents 33.1% of the blueprint. Give it enough study and hands-on time.

Testing only one successful example

Include edge cases, errors, missing data, unsafe requests, invalid tool inputs, and interrupted streams.

Treating MCP as automatic trust

MCP standardizes connections; it does not grant permission or guarantee that a tool is safe. Apply normal security controls.

Using outdated model information

Review current Anthropic documentation close to the exam. Learn selection principles rather than depending on an old model comparison.

Frequently Asked Questions

What does CCDV-F validate?

It validates foundational skills for building, integrating, and shipping production applications and agents with the Claude API, Claude Code, custom tools, and MCP servers.

Which domain is most important by weighting?

Applications and Integration is the largest at 33.1%. Model Selection and Optimisation is next at 16.8%, followed by Agents and Workflows at 14.7%.

Is CCDV-F suitable for nondevelopers?

It is designed for developers and engineers. Candidates should be comfortable with software development, APIs, command-line tools, and practical implementation.

Should I know Python or TypeScript?

The official audience profile commonly emphasizes developers comfortable with Python and/or TypeScript. More important than memorizing syntax is understanding application and API behavior.

Does the exam cover Claude Code?

Yes. Claude Code is an official domain, although its individual weighting is smaller than the application, model, or agent domains.

Is MCP included?

Yes. Tools and MCPs is a full domain worth 10.6%, covering tool implementation, MCP server development, and agentic customization.

Are practice questions enough?

No. Combine practice tests with the official Anthropic preparation course, developer documentation, and hands-on projects.

How should I prepare for multiple-response questions?

Evaluate every option independently against the scenario. Do not stop after finding one correct statement, and read how many selections are required.

How can I improve debugging skills?

Trace the request through application code, context assembly, the Claude API, tool selection, tool execution, and output validation. Use logs and identifiers to locate the failing layer.

How do I know when I am ready?

Look for consistent domain results and the ability to build, explain, secure, test, and troubleshoot a small Claude application without relying on memorized answers.

Top 10 Most Challenging CCDV-F Questions

Question 1
Domain: Applications and Integration
SINGLE CHOICE You’re building a Claude-based app to process 10,000 customer emails overnight and pull out structured data
  • A. The Batch API, built for non-interactive tasks with flexible completion windows.
  • B. The streaming responses API that handles each email and saves partial results to a database as the model generates them.
  • C. The real-time Messages API that processes emails sequentially to keep result order consistent.
  • D. The real-time Messages API with concurrent requests to maximize speed during the night window.
  • E. The task is non-interactive, runs once per day, and has a flexible several-hour deadline. Which Claude API is appropriate?
Question 2
Domain: Prompt and Context Engineering
SINGLE CHOICE Your Claude app sometimes gives confident-sounding answers that contain factual errors, which downstream systems may treat as truth. How can you address the confidence-accuracy gap?
  • A. Reduce the model temperature so responses appear less certain and downstream systems are less likely to treat them as ground truth in normal use.
  • B. Incorporate checks, source requirements, or confidence calibration before treating outputs as ground truth to temper confident output.
  • C. Block all outputs until a human reviews every response for accuracy before downstream use.
  • D. Add a blanket disclaimer on every output requesting users verify accuracy and treat the disclaimer as the main means to manage confidence vs. accuracy.
Question 3
Domain: Model Selection and Optimization
SINGLE CHOICE You need to pick a Claude model for a high-volume classification task with simple classifications, strict latency, and cost concerns per request. Which model is suitable?
  • A. A mid-range Claude model by default, balancing quality and cost for broad use.
  • B. Several Claude models in sequence; each request passes through multiple models and outputs are combined.
  • C. A smaller, faster Claude model, since the task is simple and speed and cost matter at scale.
  • D. The largest Claude model to maximize quality for every classification in normal operation.
These are the hard ones. There are 72 more. Every question explains why the wrong answers are wrong, with a link to official docs.
Get all 82 questions
Question 4
Domain: Agents and Workflows
SINGLE CHOICE You’re designing an agent for a multi-step research task. You want to split the task, assign each piece to a focused subagent, and then merge results. Which pattern fits?
  • A. An orchestrator with specialized subagents handling each subtask.
  • B. A memory pattern that pre-stores the entire history before any subtask runs.
  • C. A context-window pruning pattern that discards each subtask’s details after use.
  • D. A single tool-use loop covering all possible tools across subtasks.
Question 5
Domain: Security and Safety
SINGLE CHOICE You’re building a Claude app that processes user-entered text, which may include sensitive data like account numbers or passwords that shouldn’t reach Claude. How should you design it?
  • A. Define the app boundary, specify what can leave the boundary for Claude, and add filtering or redaction at the boundary.
  • B. Add a system-prompt instruction listing sensitive data Claude should ignore.
  • C. Log all user text before sending to Claude and review logs for sensitivity.
  • D. Filter at the boundary for common sensitive data patterns and expand coverage based on production findings.
Question 6
Domain: Tools and MCPs
SINGLE CHOICE A teammate asks you to justify why your Claude agent’s tools include detailed descriptions in the tool definition even when the tool name already conveys meaning. How would you respond?
  • A. Suggest replacing descriptions with example calls inside the tool definition as a complete substitute for prose.
  • B. Agree that tool names suffice and no extra detail is needed for tool selection.
  • C. Explain that the model uses the tool description to decide when to call it and that descriptions disambiguate cases where the name isn’t enough.
  • D. Suggest moving descriptions out of the tool definition into separate documentation so the tool definitions stay concise.
Question 7
Domain: Claude Code
SINGLE CHOICE You’re setting up configuration management for a new Claude Code project using CLAUDE.md and settings.json. How should changes be tracked and reviewed?
  • A. Duplicate CLAUDE.md and settings.json across multiple repositories to create redundancy and avoid single-source risks.
  • B. Version-control CLAUDE.md and settings.json in a separate repo from the app code so config evolves separately.
  • C. Version-control CLAUDE.md alongside code and settings.json in a separate repo.
  • D. Version-control CLAUDE.md and settings.json alongside the code with changes reviewed via standard pull requests.
Question 8
Domain: Eval, Testing, and Debugging
SINGLE CHOICE Your Claude app shows inconsistent outputs for similar inputs even with the same model and prompt. How would you debug systematically?
  • A. Lower the temperature and re-run inconsistent inputs to see if variability decreases.
  • B. Retry every unexpected response and log results to check for convergence.
  • C. Assume variability is normal LLM non-determinism and document it as expected.
  • D. Capture full traces (input, system prompt, user messages, model output, parameters) and analyze differences between consistent and inconsistent runs.
Question 9
Domain: Applications and Integration
SINGLE CHOICE The product team describes a Claude feature in business terms: agents should help analysts produce client memos faster. What’s the first technical step to translate this into requirements?
  • A. Ask analysts how memo production currently works to find where Claude could help via prompts.
  • B. Look at similar agent-based features built internally or in the industry to guide the approach.
  • C. Review available model capabilities and tiers to support memo drafting.
  • D. Interpret the functional and infrastructure requirements implied by the business goal.
Question 10
Domain: Model Selection and Optimization
SINGLE CHOICE A teammate asks why your Claude app sometimes repeats the prompt text or rewrites it in output. How would you respond?
  • A. Tell them the variation depends on which Claude model is used and pin the app to a single model version.
  • B. Explain that LLMs produce output token by token, and variation in prompt content in output is a property of generation, not a bug in request construction.
  • C. Confirm that the variation is a bug in request construction and investigate which part causes it.
  • D. Explain that the variation comes from sending two different prompts on different runs and propose pinning the system prompt to one version.
Disclaimer: Edurely is an independent educational platform. We are not affiliated with, authorized by, endorsed by, or in any way officially connected to Claude . Full disclaimer
Edurely
Curated By Edurely Team

The Edurely Team comprises certified professionals and subject matter experts dedicated to delivering accurate, up-to-date exam preparation materials. We rigorously review every resource to ensure it aligns with the latest industry standards and certification objectives to help you succeed.