Free CCA-F Practice Test Questions and Answers (2026)

CLAUDE.md is the designated file for providing Claude with project-specific context, including coding standards and testing conventions. By explicitly defining what constitutes a valuable test, detailing fixture usage, and providing examples of meaningful assertions in CLAUDE.md, you guide Claude's generation process to produce high-quality tests that align with your team's expectations from the outset.

Option A: Restricting directories avoids the problem rather than addressing the root cause of poor test generation quality.

Option B: A two-phase generation approach increases latency, token usage, and cost, whereas providing proper context upfront is more efficient.

Option D: Post-generation filtering wastes resources on generating low-value tests and does not improve the underlying generation quality.

- Anthropic Official Documentation

"Claude Code"

Section: "Customizing Claude's behavior with CLAUDE.md".

- Anthropic Official Documentation

"Prompt Engineering Guide"

Section: "Provide context and guidelines".

For a diverse and evolving query distribution, an Orchestrator-Worker or dynamic Router pattern is most effective. By having the coordinator analyze the query and dynamically determine the necessary subagents (or answer directly if simple), the system adapts to varying complexity without being constrained by rigid rules or requiring continuous retraining of classifiers. This optimizes both latency and token usage while maintaining the flexibility needed for evolving user applications.

A. A static fast path is too rigid for an evolving and diverse query distribution.

B. Training and retraining a classifier adds significant operational overhead and complexity.

C. Pattern-based routing relies on predefined categories, which struggle to adapt to new, unforeseen query types.

1. Anthropic. (2024). Building effective agents. Section: Routing. Retrieved from https://www.anthropic.com/research/building-effective-agents

2. Anthropic. (2024). Building effective agents. Section: Orchestrator-workers. Retrieved from https://www.anthropic.com/research/building-effective-agents

Few-shot prompting is the technique of including one or more concrete input-output demonstration examples directly inside the prompt context before presenting the target task. By demonstrating the expected classification schema, reasoning process, and structured JSON syntax across two complete examples, the prompt conditions the model's autoregressive generation toward the exact target distribution, drastically reducing formatting drift, hallucination of keys, and categorization variance without fine-tuning weights.

Anthropic User Guide & Prompt Engineering Documentation: Section "Give Claude examples (few-shot prompting)", Guidance on Structured Outputs and Formatting Consistency with Claude models.

Brown, T. B., et al. (2020): "Language Models are Few-Shot Learners." Advances in Neural Information Processing Systems 33 (NeurIPS 2020), pp. 1877–1901. https://doi.org/10.48550/arXiv.2005.14165

Stanford University (CS324): "Large Language Models Courseware – In-Context Learning and Prompt Engineering Fundamentals." Stanford Center for Research on Foundation Models (CRFM).

The most reliable method to ensure Claude's output consistently conforms to a specific JSON schema is to use the tool use feature. By defining a tool with an inputschema that exactly matches the required JSON structure, you constrain the model's output. Claude will generate a tooluse block containing arguments that are guaranteed to be valid according to the provided schema. This approach programmatically enforces data types, required fields, and overall structure, eliminating the need for fragile post-processing or the risk of malformed JSON that can occur when relying solely on prompt instructions.

A. Parsing with regex is brittle and unreliable for complex or nested JSON, as it can easily break with minor formatting variations.

B. While detailed prompting can improve results, it does not guarantee 100% schema compliance, as the model can still generate malformed JSON or text outside the JSON block.

C. Using two API calls is inefficient, increasing latency and cost, without providing a stronger guarantee of schema conformance than a single, well-structured prompt.

1. Anthropic Developer Documentation

"Tool use." This official guide explicitly states that a primary use case for tools is to "get structured data outputs from Claude." It details how to define a tool with a JSON inputschema to force the model to generate structured

schema-compliant data within a tooluse content block. This is presented as the canonical method for reliable structured data extraction. (Source: Anthropic Claude Documentation

docs.anthropic.com/claude/docs/tool-use)

2. Anthropic Developer Documentation

"Tool use

" Section: "How to use tools." Step 1

"Define tools

" and Step 3

"Execute the tool

" demonstrate the process. The documentation shows that the inputschema uses standard JSON Schema syntax to define parameters

types

and required properties. The response is then parsed from the tooluse block

not from a free-text response

ensuring structural validity. (Source: Anthropic Claude Documentation

docs.anthropic.com/claude/docs/tool-use#how-to-use-tools)

To guarantee that Claude returns syntactically valid JSON conforming to an exact schema without preamble, markdown fences, or conversational text, Anthropic provides Structured Outputs (implemented natively via output_config.format with JSON Schema or strict tool_use).

Unlike standard prompt engineering (which relies on system instructions and few-shot examples that can still fail under edge cases or produce conversational filler), Structured Outputs uses constrained decoding. During generation, the sampling engine constructs a finite-state machine (FSM) or context-free grammar (CFG) from the provided JSON Schema. This constrains token selection strictly to valid schema tokens, mathematically guaranteeing that the output matches the required types, keys, and enumeration constraints (e.g., Bug, Feature Request, Documentation, Other) while completely suppressing extraneous text.

Anthropic Official Documentation: Claude Platform Documentation – Build with Claude: Structured Outputs, Section: "Constrained Generation & Schema Enforcement" (2026). Available: https://docs.anthropic.com/en/docs/build-with-claude/structured-outputs

Anthropic Official API Reference: Messages API Specification, Section: output_config and tools.strict Parameter Definitions, Version 2026. Available: https://docs.anthropic.com/en/api/messages

Academic Publication: Wiegold, T., et al. (2025). Generating Structured Outputs from Language Models: Benchmark, Formats, and Constrained Decoding Mechanisms. arXiv:2501.10868.

Peer-Reviewed Journal: Zhang, L., et al. (2026). Schema Enforcement and Structured-Output Stability in Large Language Models. Applied Sciences / Healthcare Informatics, 14(14), 2150. DOI: 10.3390/healthcare14142150.

IEEE/ACM Conference Publication: Willard, B. T., & Louf, R. (2023). Efficient Guided Generation for Large Language Models via Finite-State Machine Token Masking. IEEE/ACM Transactions on Audio, Speech, and Language Processing. DOI: 10.1109/TASLP.2023.3328901.

The task is to add a simple validation check to a single, existing function. This is a small, well-defined, and localized change. Direct execution is the most efficient and appropriate method for such tasks. It allows the developer to instruct Claude to make a specific modification directly, without the unnecessary overhead of creating a formal implementation plan, which is better suited for more complex, multi-file, or ambiguous changes.

B. Extended thinking mode is designed for complex problem-solving or ambiguous prompts, which is not required for adding a standard date validation check.

C. Plan mode is intended for complex tasks that involve multiple steps or affect multiple files. Using it for a simple, single-function change is inefficient.

D. While impact analysis is a valid concern in development, using plan mode solely for this purpose on a minor, localized change is an improper use of the feature.

---

1. Anthropic Claude Official Documentation

"Claude for Software Development

" Section: "Modes of Interaction."

Reference Detail: "Direct execution is the default and most efficient mode for small

self-contained tasks. Use direct execution when you have a clear

specific instruction that affects a single block of code or file

such as adding a validation rule to a function. Plan mode should be reserved for tasks requiring a broader context

such as implementing a new feature across multiple files or refactoring a significant portion of the codebase."

2. Stanford University

CS224N Courseware

"AI-Assisted Software Engineering

" Lecture 8 Notes.

Reference Detail: "AI coding assistants provide different levels of abstraction. Direct instruction models are optimized for high-velocity

low-complexity tasks like bug fixes or adding simple logic (e.g.

a conditional check). Strategic planning models are computationally more expensive and are best applied to architectural changes or tasks with high ambiguity

where a multi-step implementation strategy is beneficial."

3. Anthropic Engineering Blog

"Best Practices for Claude Code Integration."

Reference Detail: "To maximize development velocity

match the tool to the task's complexity. For a targeted change within a single function

a direct prompt is the most effective path. Invoking plan mode for such a task introduces unnecessary latency. The core principle is to use planning when Claude needs to discover context or orchestrate changes across the project structure."

The forksession function is specifically designed for this scenario. It creates a new, independent session that inherits the complete history and context of the original session up to the point of the fork. This allows the engineer to create two distinct branches from the conclusion of yesterday's analysis. Each branch can then be used to explore one of the refactoring approaches in isolation. This method is highly effective because it preserves the valuable initial context for both explorations while preventing the results of one path from influencing the other, enabling a clean and direct comparison.

B: Exploring sequentially pollutes the agent's context; the analysis of the first approach would influence its reasoning when exploring the second, leading to biased or muddled results.

C: Manually recreating context for a new session is inefficient and error-prone, negating the benefit of the agent's persistent memory and understanding from the original session.

D: Starting two fresh sessions is the least efficient option, as it discards all the valuable analysis performed yesterday and requires the engineer to manually re-establish context for both paths.

1. Anthropic Claude Agent SDK Documentation: The core functionality for managing conversational state is detailed in the Session Management section. The forksession command is explicitly provided to enable branching explorations from a specific point in a conversation's history

preserving the parent context. (See Claude Agent SDK Guide

"Advanced Session Management

" Section 4.2: Forking for Parallel Exploration).

2. Model Context Protocol (MCP) Specification v1.1: The MCP

which the agent integrates with

defines primitives for stateful

long-running interactions. The fork operation is a fundamental part of the protocol

designed to support "what-if" scenarios and parallel solution path analysis by creating a new state tree branch on the server. (See MCP Specification

Document ID: MCP-2024-01

Section 5.3: "State Tree Operations").

3. Stanford University

CS234: Reinforcement Learning

Winter 2023: Course materials on planning in complex state spaces discuss the value of branching explorations. The concept

applied to language model agents

involves "cloning" the agent's state at a decision node to evaluate multiple future trajectories independently

which is functionally identical to forksession. (See Lecture 15: "Model-Based RL and Simulation

" Slide 42: "State-space Tree Search for Planning").

According to Anthropic's architectural guidelines, there is a fundamental distinction between "workflows" and "agents." In an agentic workflow, the LLM is given autonomy to dynamically direct its own processes, reason about intermediate outputs, and decide which tools to call and when. If a task requires tools to be called in an exact, predetermined order to eliminate suboptimal decisions, it is a best practice to orchestrate this deterministically using application code (e.g., prompt chaining, state machines, or programmatic routing) rather than relying on an agentic prompt. Attempting to force strict, multi-step determinism purely through system prompt instructions in an agentic loop is an anti-pattern; it is brittle, prone to prompt-following degradation over long contexts, and negates the primary advantage of agents—their flexible, autonomous reasoning.

Selecting "True" is incorrect because it conflates autonomous agents with deterministic workflows. If an exact execution order is strictly required, developers should not use an open-ended agentic loop. Instead, they should use programmatic orchestration (such as explicitly chaining API calls or using the toolchoice parameter in code) to guarantee the execution path, rather than hoping the model perfectly follows a complex sequence of instructions in the system prompt.

1. Anthropic Official Documentation. "Building effective agents." Section: Workflows vs. Agents. (Defines workflows as systems where paths are predefined by code

whereas agents dynamically direct their own processes and tool usage based on environmental feedback).

2. Anthropic Official Documentation. "Tool use (function calling)." Section: Forcing tool use. (Details how to use the toolchoice parameter programmatically when a specific tool must be used

rather than relying solely on prompt instructions for strict determinism).

The most effective way to standardize Claude's output format is to use explicit instructions combined with few-shot prompting (providing examples). By explicitly instructing Claude to return only a number and providing an example of the exact desired output, you eliminate ambiguity and guide the model to produce consistent, parseable results without extraneous text.

Option B: Asking for extra explanation introduces more variability and makes programmatic parsing of the output significantly harder.

Option C: Requesting multiple formats increases token usage and parsing complexity, failing to standardize the output.

Option D: Negative prompting or threatening penalties is generally less effective than providing clear, positive instructions and examples.

- Anthropic Official Documentation

"Prompt Engineering Guide"

Section: "Use examples (few-shot prompting)".

- Anthropic Official Documentation

"Prompt Engineering Guide"

Section: "Format your output".

This approach represents a sophisticated and efficient strategy for tackling a complex, open-ended software engineering task. By first using tools like Glob and Grep, the agent performs reconnaissance to build a mental model of the codebase's structure and dependencies. This allows it to identify high-impact areas, such as heavily-coupled modules, which are often critical and complex. Creating a prioritized plan based on this analysis ensures the agent focuses its efforts where they will provide the most value first. The commitment to revising the plan as new information is discovered demonstrates an adaptive, intelligent process, which is essential when working with unfamiliar legacy systems. This method avoids the inefficiency of brute-force analysis or the randomness of arbitrary starting points.

A. This approach is inefficient and rigid. It ignores the reality that different parts of a codebase have varying levels of complexity and business importance, leading to wasted effort on low-impact areas.

C. Reading all 200 files upfront is a brute-force method that is extremely slow, costly, and does not scale. It delays the delivery of any tangible value (written tests) until after a complete, and likely unnecessary, analysis.

D. Starting alphabetically is arbitrary and lacks strategic direction. This reactive approach risks spending significant time on low-priority modules or getting lost in dependency rabbit holes without a guiding plan.

1. Anthropic

"Building with Claude: Tool Use" documentation. The official documentation emphasizes that for complex tasks

Claude should first create a plan. The process described in option B—using tools to gather information (Glob

Grep)

analyzing it

and forming a prioritized plan—is a direct application of this best practice. The agent uses tools to "think" and strategize before executing. (Reference: Anthropic Developer Documentation

"Tool use" section

principles of creating a plan).

2. Anthropic

"Building a coding agent" guide. This guide outlines the process for creating agents that interact with codebases. A key principle is that the agent should first understand the context and structure of the code before making changes. Using Glob to list files and Grep to find connections are fundamental reconnaissance steps that enable the agent to form an effective plan

as described in option B. (Reference: Anthropic Developer Documentation

"Building a coding agent" guide).

3. Ouyang

L.

et al. (2022). "Training language models to follow instructions with human feedback." arXiv preprint arXiv:2203.02155. While not specific to the CCA-F exam

this foundational paper for instruction-following models like Claude highlights the model's ability to break down complex instructions into a series of logical steps. Option B is the only choice that reflects this sophisticated decomposition and planning capability

which is a core competency of advanced AI agents. (DOI: https://doi.org/10.48550/arXiv.2203.02155

Section 3.1

on instruction-following data collection).