CCAR-F Practice Questions PDF

Prévia do material em texto

https://www.passcert.com/CCAR-F.html
Page 2
23 questions selected from source version V9.02
CLAUDE CERTIFIED ARCHITECT
Question 1
You are building a multi-agent research system using the Claude Agent SDK. A coordinator agent delegates
to specialized subagents: one searches the web, one analyzes documents, one synthesizes findings, and
one generates reports. The system researches topics and produces comprehensive, cited reports.
A user expands the research system beyond its original web-search agent by adding specialized data
sources. A financial API agent returns structured JSON containing revenue, margins, and growth rates. A
news-monitoring agent returns prose summaries of recent developments. A patent-analysis agent returns
structured lists of technology areas. The synthesis agent combines these results into executive briefings.
Currently, it converts everything into bullet points, causing financial comparisons to lose tabular clarity and
news summaries to lose their narrative flow.
What change would most improve briefing quality?
A. Standardize all subagent outputs as prose summaries with inline citations.
B. Add a format-conversion layer that transforms every subagent output into a common intermediate
representation.
C. Update the synthesis agent to render each content type appropriately-for example, financial data as
tables, news as prose, and patent areas as structured lists.
D. Standardize all subagent outputs as JSON containing claim, evidence, source, and confidence fields.
Answer: C
Explanation
Option C preserves the information structure that makes each source useful. Financial metrics share comparable fields and
therefore benefit from rows, columns, aligned units, and reporting periods. News findings require connected prose to
preserve chronology and causal relationships, while patent technology areas are naturally represented as categorized lists.
Anthropic's output-consistency guidance recommends specifying the exact output format needed for the task rather than
relying on an unspecified default. Anthropic' s discussion of its multi-agent research system also recognizes specialized
output stages for reports, structured data, and visualizations because specialist prompts can produce better results than
generic coordinator processing.
Option A destroys the comparative structure of numerical data.
Option D can provide a useful provenance contract internally but does not determine how the executive briefing should
present heterogeneous content.
Option B risks creating a lowest-common-denominator representation that discards source-specific advantages. The
synthesis contract should preserve normalized facts and provenance internally while directing the report generator to select
presentation forms according to the content's semantic structure and the executive reader's needs.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 3
CLAUDE CERTIFIED ARCHITECT
Question 2
You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers
explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate
repetitive tasks. It uses the built-in tools (Read, Write, Bash, Grep, Glob) and integrates with Model Context
Protocol (MCP) servers.
An engineer asks your agent to identify untested code paths in a legacy payment processing module
spanning 45 files. After reading the first 8 source files, the agent's responses are becoming noticeably less
accurate-it' s forgetting previously discussed code patterns and hasn't yet located all test files or traced
critical payment flows.
What's the most effective approach to complete this investigation?
A. Spawn subagents to investigate specific questions (e.g., "find all test files for payment processing," "trace
refund flow dependencies") while the main agent coordinates findings and preserves high-level
understanding.
B. Clear context with /clear, then selectively re-read only the most critical files discovered so far, writing key
findings to a scratchpad file that persists between context resets.
C. Switch to using Grep to search for specific function names instead of reading full files, reducing the
content loaded into context for remaining exploration.
D. Document all current findings in a summary report, clear context completely, then use that report as the
sole reference for continuing the investigation.
Answer: A
Explanation
The investigation contains several bounded research questions that can be delegated independently: locating the complete
test suite, tracing payment and refund flows, identifying conditional branches, and mapping external dependencies. Each
subagent can read the relevant files in its own context and return a focused summary to the coordinating agent.
Anthropic recommends subagents for codebase exploration because extensive file reading rapidly consumes the main
context window. Subagents isolate that volume and return only their conclusions, preserving the main conversation for
synthesis and implementation. (https://docs.anthropic.com/en/docs/claude-code /common-workflows) Anthropic also
describes parallel research as appropriate when separate investigation paths can proceed independently and the main agent
can synthesize the results afterward. (https://docs. anthropic.com/en/docs/claude-code/sub-agents)
Option B sacrifices the current conversational state and requires reconstruction after /clear.
Option C may reduce token usage, but isolated text matches cannot reliably reveal full execution paths, indirect calls, or test
coverage relationships.
Option D converts the current analysis into a single lossy summary and risks omitting details needed later.
Option A directly addresses the demonstrated context degradation while retaining a high-level coordinating thread. The
subagent prompts should be narrowly scoped and require concrete outputs such as file paths, uncovered branches,
call-chain evidence, and existing tests associated with each flow.
Official references/topics: Subagent Context Isolation; Parallel Research; Context Preservation; Coordinated Codebase
Analysis.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 4
CLAUDE CERTIFIED ARCHITECT
Question 3
You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers
explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate
repetitive tasks. It uses the built-in tools (Read, Write, Bash, Grep, Glob) and integrates with Model Context
Protocol (MCP) servers.
A developer asks the agent to investigate why a specific API endpoint intermittently returns 500 errors. The
codebase has 200+ files and the developer doesn't know which components are involved. The agent must
trace the error through routing, middleware, business logic, and database layers.
What task decomposition approach would be most effective?
A. Have the agent first create a comprehensive plan mapping all code paths through the endpoint before
beginning any file exploration or code reading.
B. Define a fixed sequence of investigation steps upfront-grep for error patterns, then read error handlers,
then check database queries, then examine middleware-executing each step regardless of intermediate
findings.
C. Run parallel worker agents that simultaneously investigate all four layers, then synthesize their findings to
identify where the error originates.
D. Have the agent dynamically generate investigation subtasks based on what it discovers at each step,
adapting its exploration plan as new information about the error path emerges.
Answer: D
Explanation
The investigation path cannot be reliably predetermined because the responsible files, components, and execution sequence
are unknown. The agent should begin with available evidence-such as route definitions, stack traces, logs, or endpoint
references-and use each discovery to decide the next search, file read, or diagnostic action.
Anthropicdistinguishes predefined workflows from agents that dynamically direct their own processes and tool usage. Agents
are appropriate for open-ended problems where the required number and nature of the steps cannot be predicted or encoded
as a fixed path. During execution, the agent should obtain ground truth from tool results and adapt its plan based on that
environmental feedback. (https://www.anthropic.com /engineering/building-effective-agents)
Option A requires a comprehensive plan before the agent has inspected the code, so the plan would rest on unsupported
assumptions.
Option B forces every investigation through the same sequence even when an early discovery makes later steps irrelevant or
identifies a different dependency path.
Option C assumes the four layers can be investigated independently; tracing an intermittent request failure usually involves
dependencies revealed sequentially across layers.
Option D implements an adaptive agent loop: inspect, form a hypothesis, use tools, evaluate the evidence, and generate the
next subtask. The workflow should still include stopping conditions, testable hypotheses, and escalation when evidence
remains inconclusive.
Official references/topics: Adaptive Agent Loops, Dynamic Task Decomposition, Tool Feedback, Open-Ended Coding
Investigations.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 5
CLAUDE CERTIFIED ARCHITECT
Question 4
You are building a structured data extraction system using Claude. The system extracts information from
unstructured documents, validates the output using JavaScript Object Notation (JSON) schemas, and
maintains high accuracy. It must handle edge cases gracefully and integrate with downstream systems.
Your extraction pipeline processes contracts that frequently include amendments. When a contract contains
both original terms and later amendments (e.g., original clause specifies "30-day payment terms" while
Amendment 1 changes this to "45 days"), the model inconsistently extracts one value or the other with no
indication of which applies.
What's the most effective approach to improve extraction accuracy for documents with amendments?
A. Preprocess documents with a classifier that identifies and removes superseded sections before the main
extraction step.
B. Redesign the schema so amended fields capture multiple values, each with source location and effective
date.
C. Add prompt instructions to always extract the most recent amendment value and ignore superseded
original terms.
D. Implement post-extraction validation using pattern matching to detect amendments and flag those
extractions for manual review.
Answer: B
Explanation
The document contains multiple factually valid values whose applicability depends on chronology and legal context.
Collapsing those values into a single scalar field discards essential provenance.
Option B corrects the data model by representing each term as a structured record containing the extracted value, source
location, document or amendment identifier, and effective date.
Anthropic's Structured Outputs feature is designed for data-extraction use cases in which nested objects and arrays must
conform to a defined JSON Schema. (https://platform.claude.com/docs/en/build-with-claude
/structured-outputs) Anthropic also recommends grounding factual outputs in direct source material and making claims
auditable through supporting evidence. (https://docs.anthropic.com/en/docs/test-and-evaluate
/strengthen-guardrails/reduce-hallucinations) A provenance-aware schema applies both principles: it retains the original
clause and the amendment instead of forcing Claude to resolve a potentially complex legal precedence question during
extraction.
Option A is destructive because removing superseded text prevents auditing and may eliminate terms still relevant to earlier
periods.
Option C oversimplifies amendment logic; the newest document is not automatically controlling for every date, jurisdiction, or
clause.
Option D identifies risk but does not improve the extracted representation and unnecessarily sends all amendment cases to
manual review.
After extraction, deterministic business logic can select the value effective on a requested date while retaining the complete
contractual history.
Official references/topics: Structured Outputs; Nested Schema Design; Provenance and Source Grounding; Temporal Data
Modeling.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 6
CLAUDE CERTIFIED ARCHITECT
Question 5
You are building a multi-agent research system using the Claude Agent SDK. A coordinator agent delegates
to specialized subagents: one searches the web, one analyzes documents, one synthesizes findings, and
one generates reports. The system researches topics and produces comprehensive, cited reports.
The synthesis agent completes its initial pass but flags that three key research questions remain unanswered
because the web-search and document-analysis agents did not find relevant information on those specific
subtopics. The coordinator currently proceeds directly to report generation, producing reports with incomplete
coverage.
What change would most effectively improve research completeness?
A. Increase the initial breadth of queries sent to web search and document analysis to reduce the probability
of missing relevant information.
B. Have the coordinator evaluate the synthesis output for gaps, then re-delegate to web search and
document analysis with targeted queries before invoking synthesis again.
C. Have the report-generation agent note which research questions could not be answered, so users
understand the limitations of the final output.
D. Give the synthesis agent direct access to web-search tools so it can autonomously fill knowledge gaps
without returning control to the coordinator.
Answer: B
Explanation
Option B introduces an evaluator-and-refinement loop at the correct orchestration layer. The coordinator already owns the
research plan and delegation decisions, so it should inspect the synthesis result against the required questions, identify
coverage gaps, and issue focused follow-up assignments. Anthropic's description of its multi-agent research system follows
this pattern: the lead agent synthesizes returned findings, determines whether additional research is required, and creates
new subagents or refines its strategy before producing the final result. Increasing the initial query breadth, option A, may
generate additional irrelevant material and cannot guarantee that unforeseen gaps will be covered.
Option C merely documents the incompleteness instead of correcting it.
Option D weakens role separation by giving the synthesis agent search capabilities, increasing tool complexity and
bypassing the coordinator's centralized tracking. Targeted re-delegation preserves specialized responsibilities and creates an
observable sequence of research, evaluation, refinement, and resynthesis. The coordinator should also maintain explicit
coverage criteria and limit the number of refinement rounds so the system improves completeness without entering an
uncontrolled research loop.
CLAUDE CERTIFIED ARCHITECT
Question 6
You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers
explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate
repetitive tasks. It uses the built-in tools (Read, Write, Bash, Grep, Glob) and integrates with Model Context
Protocol (MCP) servers.
1.5An engineer asks the agent to understand how the caching layer works before adding a new cache
invalidation trigger. After initial Grep searches, the agent has identified that caching logic spans 15 files
including decorators, middleware, and service classes (~6,000 lines total).
What's the most effective next step for building understanding while managing context constraints?
A. Use Grep to search for "invalidate" and "expire" patterns across all files, then Read only thosespecific line
ranges with minimal surrounding context.
B. Use the Read tool to sequentially load all 15 files, building complete understanding across the full caching
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 7
Question 6 continued
implementation.
C. Use Glob to find files matching common caching patterns (cache*.py, caching/), prioritize the largest files
by reading them first, then check smaller files for gaps.
D. Analyze imports and class hierarchies to identify the base cache class. Read that file to understand the
interface, then trace specific invalidation implementations.
Answer: D
Explanation
The correct objective is to construct an architectural map before consuming the full implementation. Identifying the base
cache abstraction, its interface, and the classes that implement or invoke it gives the agent a dependency-guided path
through the code. It can then inspect only the invalidation implementations and integration points relevant to the proposed
trigger.
This approach protects the context window. Anthropic states that every file read occupies context and that model
performance can deteriorate as the window fills. Its Claude Code guidance warns against unbounded investigation that reads
large numbers of files and recommends narrowing the exploration or delegating it.
(https://code.claude.com/docs/en/best-practices)
Option A is too lexical: searching only for invalidate or expire can miss event-driven invalidation, overridden methods,
cache-key mutation, and generic interface calls.
Option B loads approximately 6,000 lines without first establishing relevance.
Option C assumes that filename patterns and file size correlate with architectural importance; the largest files may contain
incidental code while a small interface defines the entire design.
Option D follows control and type relationships rather than arbitrary file order. After reading the base class, the agent can
search for subclasses, imports, construction sites, middleware hooks, and calls to the invalidation contract, progressively
expanding only where evidence requires it.
Official references/topics: Context-Efficient Exploration; Dependency-Guided Reading; Architectural Interfaces; Narrowly
Scoped Investigation.
CLAUDE CERTIFIED ARCHITECT
Question 7
You are integrating Claude Code into your Continuous Integration/Continuous Deployment (CI/CD) pipeline.
The system runs automated code reviews, generates test cases, and provides feedback on pull requests.
You need to design prompts that provide actionable feedback and minimize false positives.
Your pipeline includes a release-notes generation step that classifies and summarizes approximately 200
commits at the end of each weekly release cycle. Each commit is currently sent as a separate Messages API
request using a Sonnet-tier Claude model. The release notes are not needed until the following morning,
providing approximately 12 hours of acceptable latency.
Your team must reduce the per-token API cost while retaining the same model, prompts, and output quality.
Which approach satisfies all these constraints?
A. Issue the 200 Messages API requests concurrently because parallel execution reduces the per-token
price.
B. Submit the 200 requests through the Message Batches API with unique custom_id values and retrieve the
results after the batch finishes.
C. Concatenate all 200 commit messages into one Messages API request because reducing the number of
requests always reduces token costs.
D. Replace the Sonnet-tier model with a Haiku-tier model to obtain a lower per-token price.
Answer: B
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 8
Question 7 continued
Explanation
Option B applies Anthropic's dedicated asynchronous bulk-processing mechanism while preserving the existing model and
prompt for every commit. The Message Batches API accepts independent Messages API requests, each identified by a
unique custom_id, and charges both input and output usage at 50% of standard API prices. The approximately 12-hour
latency allowance makes the release-notes workload well suited to batching because immediate results are unnecessary.
Option A may reduce wall-clock completion time, but concurrency does not alter the API's per-token price.
Option C changes the task structure and risks exceeding context or output limits, mixing commit-level classifications,
complicating retries, and making it harder to associate errors with individual commits. A single large request also does not
automatically consume fewer tokens because the model must still process all commit content.
Option D violates the requirement to retain the same model tier and output-quality profile. Batch results may arrive in an order
different from submission order, so the pipeline must associate every response with its original commit through custom_id.
This provides lower cost without changing the individual review prompts. Anthropic Message Batches documentation
CLAUDE CERTIFIED ARCHITECT
Question 8
You are building a multi-agent research system using the Claude Agent SDK. A coordinator agent delegates
to specialized subagents: one searches the web, one analyzes documents, one synthesizes findings, and
one generates reports. The system researches topics and produces comprehensive, cited reports.
After the web-search and document-analysis subagents complete their tasks, the coordinator needs to
spawn the synthesis subagent to synthesize the findings.
What is the correct approach for providing the synthesis subagent with the information it needs?
A. Provide the subagent with tool definitions that allow it to request outputs from other subagents through
callbacks.
B. Include the complete findings from both subagents directly in the synthesis subagent's prompt.
C. Spawn the subagent with only a brief task description, relying on automatic context inheritance from the
coordinator.
D. Pass reference identifiers and configure the subagent with read access to a shared memory store where
the other subagents deposited their results.
Answer: B
Explanation
Option B follows the Claude Agent SDK's subagent context model. A normal subagent begins with a fresh context window
and does not inherit the parent agent's conversation history or prior tool results. Anthropic's Subagents in the SDK
documentation states that the information passed from parent to subagent is the spawning tool's prompt string; required file
paths, decisions, errors, or findings must therefore be included in that prompt. In this scenario, the coordinator should supply
both agents' relevant findings, source metadata, and explicit synthesis instructions. "Complete findings" means the full
required result artifacts, not every intermediate search trace.
Option C incorrectly assumes automatic context inheritance.
Option A introduces callbacks that are neither necessary nor the standard handoff mechanism.
Option D can be a valid custom architecture when a shared store has deliberately been implemented, but the question does
not establish such infrastructure, and identifiers alone do not give the subagent information. The prompt should use clear
sections or structured objects to distinguish web findings, document findings, sources, unresolved conflicts, and expected
output. This preserves context isolation while providing everything the synthesis task actually requires.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 9
CLAUDE CERTIFIED ARCHITECT
Question 9
You are integrating Claude Code into your Continuous Integration/Continuous Deployment (CI/CD) pipeline.
The system runs automated code reviews, generates test cases, and provides feedback on pull requests.
You need to design prompts that provide actionable feedback and minimize false positives.
Your pipeline runs:
PROMPT= ' You are a code reviewer. Analyze the provided diff for bugs, security issues, and style violations.
'
claude -p \
--dangerously-skip-permissions \
--system-prompt" $PROMPT " \
pipeline.
The system runs automated code reviews, generates test cases, and provides feedback on pull requests.
You need to design prompts that provide actionable feedback and minimize false positives.
In addition to your CI pipeline, your organization has enabled Claude's managed Code Review through the
Claude GitHub App on this repository, and reviews run automatically on every pull request. Reviews average
18 findings per pull request. Developer feedback reveals three categories of unwanted noise: (1) style and
formatting issues already enforced by your linter in CI, (2) findings on automatically generated template code
under src/gen/, and (3) rendering-helper patterns that are intentional project conventions but get flagged
because they resemble common anti-patterns. Only approximately four findings per pull request are genuine
logic bugs.
What is the most effective way to reduce this noise while preserving the detection of genuine issues?
A. Create a REVIEW.md file at the repository root containing skip rules for CI-enforced checks and
generated files, together with a verification requirement that rendering-related findings cite a specific line
demonstrating incorrect behavior.
B. Add custom review instructions to a GitHub Actions workflow file, using the action's prompt parameter to
suppress duplicate lint findings, ignore generated template code, and apply stricter evidence requirements to
rendering-related issues.
C. Add detailed explanations to the project's CLAUDE.md describing which patterns are intentional, that
linting is handled separately by CI, and that the src/gen/directory contains automatically generated template
code.
Answer: A
Explanation
Option A uses the dedicated control surface for managed Claude Code Review. Anthropic's Code Review documentation
states that a root-level REVIEW.md is injected into every review agent as the highest-priority instruction block. It can define
skip paths, suppress categories already enforced by CI, recalibrate severity, cap nit volume, and require source evidence
before reporting particular findings. The documentation explicitly identifies generated code, linting, and verification
requirements as appropriate uses.
Option B configures a self-hosted GitHub Actions workflow, but the scenario concerns the separate managed Code Review
service running on Anthropic's infrastructure. Instructions in that workflow do not control the managed reviewer.
Option C provides useful general project context, but CLAUDE.md has lower review-specific authority: managed Code
Review treats violations of it primarily as nit-level findings. REVIEW.md is the stronger and more precise mechanism for
changing what the managed service reports. The file should skip src/gen/**, suppress style issues already enforced by CI,
and require concrete behavioral evidence for rendering-helper warnings while continuing to report verified correctness and
security defects.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 13
CLAUDE CERTIFIED ARCHITECT
Question 13
You are building a multi-agent research system using the Claude Agent SDK. A coordinator agent delegates
to specialized subagents: one searches the web, one analyzes documents, one synthesizes findings, and
one generates reports. The system researches topics and produces comprehensive, cited reports.
Production monitoring shows that follow-up queries such as "summarize what we learned about market
trends" consistently take more than 40 seconds. Investigation reveals that the coordinator spawns the
synthesis subagent for each summarization request, passing more than 80,000 tokens of accumulated
findings. The coordinator already has these findings in its context from orchestrating the research.
What is the most effective way to improve response time for these follow-up summaries?
A. Spawn the synthesis subagent with reduced context and have it request specific findings from the
coordinator on demand.
B. Have the coordinator handle straightforward summarization requests directly using its existing context,
reserving subagent spawning for complex analysis.
C. Pre-generate and cache summaries at multiple granularities whenever new findings accumulate.
D. Enable prompt caching on the synthesis subagent to reduce the overhead of repeatedly transferring the
same research findings.
Answer: B
Explanation
Option B eliminates an unnecessary agent boundary. The coordinator already possesses the accumulated findings and can
answer a straightforward follow-up without serializing more than 80,000 tokens into a fresh subagent context, waiting for
another model execution, and receiving the result back. Anthropic's multi-agent research engineering guidance emphasizes
scaling effort to task complexity: simple fact-finding or lightweight processing should use substantially fewer agents and tool
calls than complex research. It also reports that multi-agent systems consume far more tokens than ordinary interactions,
making avoidable delegation expensive and slow.
Option A adds an interactive retrieval protocol between agents and additional round trips.
Option C spends compute proactively on summaries that users may never request and creates cache-invalidation problems
whenever findings change.
Option D could reduce repeated input cost where caching is applicable, but the subagent still receives and processes an
unnecessarily large context and still incurs spawning latency. Delegation is valuable when an isolated context or specialized
capability materially improves the result. For a direct summary already supported by the coordinator's active context, local
handling is the faster and simpler architecture.
CLAUDE CERTIFIED ARCHITECT
Question 14
You are building developer productivity tools using the Claude Agent SDK. The agent helps engineers
explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate
repetitive tasks. It uses the built-in tools (Read, Write, Bash, Grep, Glob) and integrates with Model Context
Protocol (MCP) servers.
Your agent has analyzed a complex service module-reading 23 source files, tracing request flows, and
identifying error handling patterns. A developer wants to compare two testing strategies before committing to
one: end-to-end tests with mocked external services vs. snapshot tests capturing expected outputs. They
need to independently develop both approaches to evaluate trade-offs.
How should you manage the sessions?
A. Resume the analysis session with fork_session enabled, creating a separate branch for each testing
strategy.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 14
Question 14 continued
B. Start two fresh sessions, having each re-read the relevant source files before beginning.
C. Continue in the original session, developing end-to-end tests first, then snapshot tests sequentially.
D. Export the analysis session's key findings to a file, then create two new sessions that reference this file.
Answer: A
Explanation
Forking the existing analysis session creates independent continuations that inherit the accumulated conversation context.
Each branch begins with the same understanding of the service module, request flow, source files, and error-handling
patterns, but subsequent work on one testing strategy does not alter the other branch or the original session.
Anthropic's Agent SDK documentation states that sessions can be resumed with their full context and forked to explore
different approaches. In the SDK, enabling fork_session while resuming causes the continuation to receive a new session
identifier rather than modifying the original session. (https://docs.anthropic.com/en
/docs/claude-code/sdk?utm_source=chatgpt.com)
Option B wastes time, tokens, and tool calls by requiring both new sessions to rebuild the same 23-file analysis.
Option C mixes two experimental implementations into one conversation, increasing the risk that assumptions, edits, or
conclusions from the first strategyinfluence the second.
Option D preserves only a manually selected summary, which may omit details contained in the full session history.
The appropriate design is to create one fork for the end-to-end strategy and another fork for the snapshot strategy. The
original analysis remains a stable parent, while each child session develops and evaluates its approach independently.
Official references/topics: Agent SDK Sessions, Session Forking, Context Preservation, Alternative-Approach Evaluation.
CLAUDE CERTIFIED ARCHITECT
Question 15
You are building developer-productivity tools using the Claude Agent SDK. The agent helps engineers
explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate
repetitive tasks. It uses the built-in tools-Read, Write, Bash, Grep, and Glob-and integrates with Model
Context Protocol (MCP) servers.
An engineer who recently joined the team asks the agent to explain the authentication and authorization
architecture before making security improvements. The codebase contains more than 800 files across
multiple services.
What exploration strategy will most effectively build understanding while respecting context limits?
A. Launch parallel subagents to explore every service simultaneously, and then synthesize their findings into
an architectural overview.
B. Read all files containing auth, login, permission, or token in their filenames or contents.
C. Read all CLAUDE.md and README files first, and then ask the engineer to identify the 10-15 most
important authentication files.
D. Use Grep to locate authentication entry points, read those files, and then follow imports and function calls
incrementally to map the authentication flow.
Answer: D
Explanation
Option D builds an evidence-based architectural map without indiscriminately loading hundreds of files. Authentication entry
points may include route handlers, middleware registration, token-validation functions, session constructors, or
identity-provider callbacks. After Grep identifies those anchors, targeted Read operations can establish their responsibilities,
while imports, call sites, and configuration references reveal the downstream authorization flow. Anthropic's large-codebase
guidance recommends scoping Claude to the portion of a repository touched by the task because unrelated instructions and
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 15
Question 15 continued
file reads consume tokens and degrade performance. Its common workflows guidance similarly recommends beginning
broadly and narrowing into specific components.
Option A launches agents before the relevant service boundaries are known and may produce overlapping, inconsistent
investigations.
Option B is an uncontrolled lexical sweep that will include tests, documentation, unrelated tokens, and incidental terminology.
Option C appropriately checks project guidance but incorrectly delegates technical file selection to a new engineer who may
not know the architecture. Incremental dependency tracing maintains context efficiency while producing a verifiable
end-to-end map grounded in actual code paths.
CLAUDE CERTIFIED ARCHITECT
Question 16
You are using Claude Code to accelerate software development. Your team uses it for code generation,
refactoring, debugging, and documentation. You need to integrate it into your development workflow with
custom slash commands, CLAUDE.md configurations, and understand when to use plan mode vs direct
execution.
You've asked Claude Code to build a PDF report generation feature. The initial implementation queries the
database correctly, but the output has formatting issues: table columns are too narrow causing content
truncation, dates display without proper formatting, and page break handling is incorrect. You've noticed
these issues interact-changing column widths affects how dates render, and page breaks depend on content
height.
What's the most effective approach for iterating toward a working solution?
A. Start fresh with a detailed prompt specifying all formatting requirements upfront.
B. Provide all three issues in a single detailed message with exact specifications for each, allowing Claude to
address them together in one update.
C. Address the column width issue first with specific measurements, verify it works, then fix date formatting
within the corrected columns, then adjust page breaks-testing after each change.
D. Show Claude an example of a correctly formatted report and ask it to match that output, rather than listing
the specific technical issues.
Answer: C
Explanation
The defects are coupled, so changing all three simultaneously would make it difficult to determine which modification caused
an improvement or regression.
Option C establishes a controlled sequence: correct the foundational column geometry, verify the resulting layout, format
dates within the stabilized columns, and finally tune page breaks using the resulting content heights.
Anthropic recommends tight feedback loops and early course correction. It also advises supplying Claude with an executable
or observable verification mechanism, such as a test, build result, generated fixture, or screenshot comparison. Claude can
then make a focused change, inspect the output, and iterate until that specific condition is satisfied.
(https://code.claude.com/docs/en/best-practices)
Option A discards useful context from the functioning database implementation.
Option B changes multiple interacting variables in one pass, making failures harder to isolate.
Option D provides a useful visual target but does not replace precise technical constraints or incremental verification.
Each stage should have explicit acceptance criteria-for example, minimum column widths, expected date strings, and
page-break fixtures using short and long content. Once a stage passes, its test becomes a regression guard for subsequent
changes.
Official references/topics: Incremental Refinement; Tight Feedback Loops; Observable Verification; Regression Control.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 16
Question 16 continued
CLAUDE CERTIFIED ARCHITECT
Question 17
You are building developer-productivity tools using the Claude Agent SDK. The agent helps engineers
explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate
repetitive tasks. It uses the built-in tools-Read, Write, Bash, Grep, and Glob-and integrates with Model
Context Protocol (MCP) servers.
An engineer sees the unfamiliar error message SYNC_CONFLICT: entity version mismatch detected in
production logs but does not know which of the 12 services in the codebase generates it. The engineer asks
the agent to locate the responsible source code.
What exploration approach will find the responsible code most efficiently?
A. Use Grep to search for distinctive text from the error message, such as SYNC_CONFLICT or entity
version mismatch, and then read the matching files to understand the context.
B. Use Glob to find files in directories commonly associated with error handling, such as errors, exceptions,
or handlers, and then read every matching file.
C. Read the project's README and service-configuration files, and then systematically read source files in
every service directory.
D. Use Grep to locate every file importing the project's error-handling module, and then read those files to
find custom error definitions.
Answer: A
Explanation
Option A begins with the strongest available discriminator: the exact production error text. Anthropic's tools reference
specifies that Grep searches file contents and returns matching lines, enabling the agent to locate a literal error constant or
message without loading the full repository. Searching both the stable code SYNC_CONFLICT and the distinctive phrase
protects against cases where the identifier and displayed message are defined separately. The agent can then read only the
matching files and follow the surroundingcall path, error construction, and service ownership.
Option B assumes that errors are stored in conventionally named directories, which may not hold in a twelve-service
repository.
Option C consumes substantial context before using the most direct evidence.
Option D narrows the search to consumers of a known shared error module, but the message may be locally defined,
generated from configuration, or wrapped by another component. Grep followed by targeted Read operations follows
Anthropic's broader context-engineering principle of retrieving relevant source material just in time instead of placing an
entire codebase into the active context.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 17
CLAUDE CERTIFIED ARCHITECT
Question 18
You are using Claude Code to accelerate software development. Your team uses it for code generation,
refactoring, debugging, and documentation. You need to integrate it into your development workflow with
custom slash commands, CLAUDE.md configurations, and understand when to use plan mode vs direct
execution.
Your team has three requirements for Claude Code's behavior in your project:
● Claude must never modify files in the db/migrations/directory.
● Claude should prefer your custom logging module over console.log.
● All TypeScript files must be auto-formatted with Prettier after every edit.
All three are currently written as instructions in your project's CLAUDE.md. During a complex refactoring
session, a developer discovers that Claude edited a migration file, violating requirement #1.
How should you restructure these requirements across Claude Code's configuration mechanisms?
A. Move all three requirements into .claude/rules/as path-scoped rules: one targeting db/migrations/** that
forbids editing those files, and others targeting **/*.ts for the logging convention and formatting instruction.
B. Configure hooks for all three: a PreToolUse hook script that blocks Edit calls targeting db/migrations/, a
PreToolUse hook script that adds logging convention context before edits, and a PostToolUse hook that runs
Prettier after TypeScript edits.
C. Rewrite all three requirements in CLAUDE.md using stronger directive language and add few-shot
examples that demonstrate Claude refusing to edit migration files and running Prettier after edits.
D. Add Edit(./db/migrations/**) to permissions.deny in the project settings, keep the logging preference in
CLAUDE.md, and add a PostToolUse hook to run Prettier after TypeScript edits.
Answer: D
Explanation
Each requirement belongs in the mechanism matching its enforcement semantics. The migration restriction is a hard safety
boundary, so it should be implemented through permissions.deny, not merely expressed as contextual guidance. Anthropic
explicitly states that CLAUDE.md content is treated as context rather than enforced configuration. Permission rules use the
Tool(specifier) form, evaluate deny rules before ask or allow rules, and support path-based Edit(...) restrictions.
(https://code.claude.com/docs/en/memory)
The custom logging convention is a persistent project preference, making CLAUDE.md the appropriate location. It should
guide Claude's code-generation decisions but does not require deterministic interception. Prettier formatting, by contrast, is
deterministic automation. Anthropic documents the exact pattern of using a PostToolUse hook with an Edit|Write matcher to
run Prettier automatically after file modifications. (https://code.claude.com/docs/en/hooks-guide)
Option A incorrectly treats path-scoped rules as a security control; rules remain instructions.
Option B overuses hooks for a semantic coding preference that belongs in CLAUDE.md.
Option C relies entirely on stronger prompting, which cannot guarantee that protected files remain untouched.
Option D correctly separates prohibition, preference, and automatic enforcement.
Official references/topics: Permission rules, CLAUDE.md semantics, PostToolUse formatting hooks.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 18
CLAUDE CERTIFIED ARCHITECT
Question 19
You are building a multi-agent research system using the Claude Agent SDK. A coordinator agent delegates
to specialized subagents: one searches the web, one analyzes documents, one synthesizes findings, and
one generates reports. The system researches topics and produces comprehensive, cited reports.
The coordinator agent has AgentDefinition objects configured for all four specialized subagents, each with
appropriate descriptions, prompts, and tool restrictions. During testing, you notice that the coordinator
correctly reasons about when to delegate-it generates messages such as, "I'll ask the web-search agent to
find sources on this topic"-but no subagent execution ever occurs. The coordinator then proceeds as if the
delegation happened and continues with incomplete information. Logs show no errors.
What is the most likely cause?
A. The AgentDefinition objects are configured correctly, but the coordinator's system prompt does not
explicitly list the available subagent types, preventing the model from knowing that they can be invoked.
B. Subagent context isolation means task descriptions from the coordinator do not automatically reach
subagents; you must configure explicit context forwarding in ClaudeAgentOptions.
C. The coordinator's allowedTools configuration does not include Agent-formerly named Task-so it cannot
invoke the tool required to spawn subagents.
D. The coordinator's max_tokens setting is too low, causing the subagent tool invocation to be truncated
before the subagent type can be specified.
Answer: C
Explanation
Option C matches the distinction between reasoning about delegation and executing it. Defining subagents makes their
descriptions available for selection, but the coordinator must still invoke the SDK's subagent-
spawning tool. Current Claude Agent SDK documentation calls this the Agent tool; Task was its earlier name and remains
relevant to older SDK configurations. Anthropic's Subagents in the SDK documentation instructs developers to include Agent
in allowedTools so subagent invocations are approved automatically. Without that permission, an invocation can fall through
to a permission callback or be denied under a non-interactive permission mode.
Option A is unlikely because the configured subagent descriptions already tell Claude when each agent should be selected,
although explicit prompting can improve invocation reliability.
Option B misstates context isolation: context must be included in the spawning prompt, but that issue occurs after an
invocation is attempted and does not explain the absence of all subagent executions.
Option D would normally produce truncation evidence or incomplete output rather than consistent verbal promises with no
tool call. The configuration should therefore permit Agent, explicitly request delegation where necessary, and log subagent
invocation events.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 19
CLAUDE CERTIFIED ARCHITECT
Question 20
You are building a structured data extraction system using Claude. The system extracts information from
unstructured documents, validates the output using JavaScript Object Notation (JSON) schemas, and
maintains high accuracy. It must handle edge cases gracefully and integrate with downstream systems.
Your pipeline uses a tool called extract_metadata with a JSON schema for paper details. You've also defined
lookup_citations and verify_doi tools for enrichment. During testing, you notice that when users include
requests like "extract the metadata and tell me how cited it is," Claude sometimes calls lookup_citations first,
which fails because it needs the DOI that extract_metadata would provide.
What's the most effective way to ensure structured metadata extraction happens first?
A. Set tool_choice to { " type " : " tool ", " name " : " extract_metadata " } and process the enrichment
requestsin subsequent turns after receiving the extracted metadata.
B. Set tool_choice to " auto " and reorder the tool definitions so extract_metadata appears first in the tools
array, since Claude prioritizes earlier-listed tools.
C. Set tool_choice to { " type " : " tool ", " name " : " extract_metadata " } for every API call in the pipeline,
ensuring Claude always extracts metadata before any enrichment can occur.
D. Set tool_choice to " any " so Claude must use a tool, combined with system prompt instructions prioritizing
extract_metadata.
Answer: A
Explanation
The dependency must be enforced by orchestration rather than left to probabilistic tool selection. Anthropic documents that
tool_choice: { " type " : " tool ", " name " : " ... " } forces Claude to invoke the specified tool. By contrast, auto allows Claude to
decide whether and which tool to call, while any requires some tool but does not force a particular one.
(https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools)
Option A therefore establishes a deterministic two-stage workflow. The first API turn forces extract_metadata, producing the
DOI and other structured paper details. The application validates and stores that result. A subsequent turn then exposes or
permits verify_doi and lookup_citations, passing the extracted DOI as explicit state. This design converts an implicit tool
dependency into an application-controlled execution graph.
Option B is incorrect because array order is not a documented precedence mechanism and cannot guarantee selection.
Option C forces extract_metadata on every call, including turns where enrichment should occur, potentially creating an
infinite or non-progressing workflow.
Option D guarantees only that one available tool is called; Claude could still select lookup_citations before the DOI exists.
For stronger input integrity, the tools can also use strict schemas so their arguments conform to the declared JSON Schema.
The sequencing requirement, however, remains the responsibility of the orchestration layer.
Official references/topics: Tool Choice; Forced Tool Invocation; Multi-Turn Tool Orchestration; Tool Dependency
Management.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 20
CLAUDE CERTIFIED ARCHITECT
Question 21
You are building a customer support resolution agent using the Claude Agent SDK. The agent handles
high-ambiguity requests like returns, billing disputes, and account issues. It has access to your backend
systems through custom Model Context Protocol (MCP) tools (get_customer, lookup_order, process_refund,
escalate_to_human). Your target is 80%+ first-contact resolution while knowing when to escalate.
Production logs reveal inconsistent error handling: when lookup_order fails, the agent sometimes retries 5+
times (wasteful when the order ID doesn't exist), sometimes escalates immediately (premature for temporary
network issues), and sometimes asks users for clarification (inappropriate when the issue is a backend
permission error). Investigation shows your MCP tool returns uniform error responses: { " isError " : true, "
content " : [{ " type " : " text ", " text " : " Operation failed " }]}. The agent cannot distinguish between error
types.
What's the most effective improvement?
A. Enhance error responses with structured metadata-include error_category (transient/validation
/permission), isRetryable boolean, and a description of what caused the failure.
B. Implement retry logic with exponential backoff in your MCP server for all errors, returning to the agent only
after retries are exhausted.
C. Create an analyze_error MCP tool the agent calls after any failure to determine the error category and
recommended action.
D. Add few-shot examples to the system prompt demonstrating how to interpret error message patterns and
select appropriate responses for each.
Answer: A
Explanation
The agent is behaving inconsistently because every failure is represented identically. "Operation failed" contains no
information about permanence, user correctability, authorization, or whether another attempt is likely to succeed. Adding
structured fields converts the error into an actionable interface contract.
Anthropic instructs tool implementations to mark failures using an error flag and return information Claude can use to retry
with corrected input, ask for clarification, or explain a limitation. Tool design should expose sufficient detail for the model to
choose the correct next action rather than forcing it to infer the cause from a generic message.
(https://platform.claude.com/docs/en/agents-and-tools/tool-use/build-a-tool-using-agent? utm_source=chatgpt.com)
With error_category, isRetryable, and a causal description, the agent can retry transient network failures, request corrected
identifiers for validation errors, and escalate or report permission failures without pointless repetitions.
Option B retries permanent validation and permission failures unnecessarily.
Option C adds another tool call and failure point merely to classify information the original tool already possesses.
Option D relies on parsing variable text and examples rather than providing explicit machine-readable semantics.
The tool should preserve isError: true, return a stable structured error object, include a safe customer-facing message where
appropriate, and avoid exposing internal secrets or stack traces.
Official references/topics: MCP error contracts, actionable tool results, retryability metadata, agent-computer interface design.
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 21
CLAUDE CERTIFIED ARCHITECT
Question 22
You are building developer-productivity tools using the Claude Agent SDK. The agent helps engineers
explore unfamiliar codebases, understand legacy systems, generate boilerplate code, and automate
repetitive tasks. It uses the built-in tools-Read, Write, Bash, Grep, and Glob-and integrates with Model
Context Protocol (MCP) servers.
You are building a security-scanning workflow.
When engineers need to locate every occurrence of a dangerous function such as eval() across a large
codebase, which tool should the agent use for content searching?
A. Use Glob with a pattern such as **/eval* to locate files, and then read each matching file.
B. Use Grep to search for the regular-expression pattern eval\(across all files in the codebase.
C. Read the project's main entry file and follow import statements to trace where eval() might be used.
D. Use Bash to run ls -R | grep eval and search the recursively listed filenames.
Answer: B
Explanation
Option B uses the tool designed to search file contents. Anthropic's Claude Code tools reference distinguishes Grep from
Glob: Grep searches lines inside files, whereas Glob matches filenames and paths. Grep is built on ripgrep and accepts
regular-expression patterns, so the opening parenthesis should be escaped as eval\(when the intention is to match the literal
function call. The search can return matching files, line numbers, and surrounding context without loading every file into the
model's context window.
Option A searches filenames resembling eval, not source files whose contents invoke the function.
Option C follows only code reachable from a selected entry point and can miss test utilities, dynamically loaded modules,
scripts, and dormant vulnerable code.
Option D combines a recursive filename listing with text filtering; it still searches names rather than file contents. After Grep
identifies matches, the agent should use Read on the relevant ranges to distinguish actual executable calls from comments,
strings, or safe wrappers. Grep therefore provides the most complete and context-efficient initial security scan.
CLAUDE CERTIFIED ARCHITECT
Question 23
The coordinator agent has AgentDefinition objects configured for all four specialized subagents, each with
appropriate descriptions, prompts, and tool restrictions. During testing, you notice that the coordinatorcorrectly reasons about when to delegate-it generates messages such as, "I'll ask the web-search agent to
find sources on this topic"-but no subagent execution occurs. The coordinator then proceeds as if the
delegation happened and continues with incomplete information. Logs show no errors.
What is the most likely cause?
A. The AgentDefinition objects are configured correctly, but the coordinator's system prompt does not
explicitly list the available subagent types.
B. The coordinator's allowedTools configuration does not include " Agent " -called " Task " in older SDK
releases-so it cannot invoke the tool required to spawn subagents.
C. Subagent context isolation prevents task descriptions from reaching subagents unless explicit context
forwarding is configured in ClaudeAgentOptions.
D. The coordinator's max_tokens setting is too low, causing the subagent invocation to be truncated before
the agent-type parameter is specified.
Answer: B
https://www.passcert.com/CCAR-F.html
https://www.passcert.com/CCAR-F.html
Page 22
Question 23 continued
Explanation
Option B identifies the missing executable capability. Defining specialized agents makes their configurations available, but
the coordinator must still be permitted to call the tool that invokes them. Without that tool, Claude can describe an intended
delegation in ordinary text but cannot create a subagent execution.
The current Claude Agent SDK documentation requires " Agent " in allowedTools to auto-approve subagent invocations. The
tool was renamed from " Task " to " Agent " in Claude Code 2.1.63, so the terminology in the original candidate question
required correction. Older integrations may still expose " Task " in initialization or permission records.
Option A is unlikely because properly written AgentDefinition.description values already tell Claude when each agent should
be used.
Option C misinterprets context isolation: the parent supplies the subagent's assignment through the Agent tool's prompt, and
no additional automatic forwarding setting is required.
Option D would normally produce truncation evidence or a max_tokens stop reason rather than silent absence of every
invocation. The coordinator needs both agent definitions and permission to use the invocation tool.
https://www.passcert.com/CCAR-F.html