CCAR-F Claude Certified Architect - Foundations Exam Preparation Resources - Free Latest Dumps for IT Certification Exams

CCAR-F Claude Certified Architect – Foundations Exam Preparation Resources

dumps2026-07-21T14:33:41+08:00

CCAR-F Claude Certified Architect – Foundations exam is pop among those candidates. We all know that there are 60 multiple-choice questions in real CCAR-F exam, and you have 120 minutes to answer all the questions. The required passing score of CCAR-F exam is 720 (the total points is 1000). We provide the latest Claude Certified Architect – Foundations CCAR-F exam preparation material, which are useful for you to take the test. Free Claude Certified Architect – Foundations CCAR-F exam preparation resources are available below.

Page 1 of 10

1. When designing an automated code review system for a large repository, you notice that developers are experiencing 'alert fatigue' because the AI flags too many non-issues and stylistic preferences.

What is the most effective prompt engineering technique to reduce these false positives?

Instruct the model to be thorough and flag everything suspicious to ensure no bugs are missed.

Define explicit, measurable review criteria, such as flag functions exceeding 50 lines of code, instead of relying on vague instructions.

Set the model's temperature to 0.0 to ensure deterministic output and eliminate all false positives.

Provide at least 15 few-shot examples covering every possible coding style in the repository.

2. You are building a classifier to categorize customer reviews, but the model struggles with ambiguous scenarios like sarcasm and mixed sentiments. You decide to use few-shot prompting.

What is the recommended best practice for this scenario?

Provide exactly 1 example of a standard positive review to establish the JSON format.

Provide 8 to 10 examples to ensure every possible sentiment category is covered comprehensively.

Provide 2 to 4 examples, ensuring that at least one example specifically addresses an ambiguous edge case like sarcasm.

Avoid few-shot prompting and instead use a detailed system prompt explaining the exact definition of sarcasm.

3. A pull request modifies 14 files across a stock tracking module. When analyzing all files in a single pass, Claude provides superficial comments, misses obvious bugs, and produces contradictory feedback.

How should you redesign the multi-pass review architecture to resolve this?

Switch to a higher-tier model with a larger context window so all 14 files receive adequate attention in one pass.

Require developers to manually split large PRs into smaller submissions of 3-4 files before triggering the automated review.

Run three independent single-pass reviews on the full PR and only flag issues that achieve consensus across at least two runs.

Split the review into focused passes: analyze each file individually for local issues, followed by a separate integration-focused pass for cross-file data flow.

4. In a Continuous Integration (CI) pipeline, you run a script where a single Claude session generates a block of code and then immediately reviews its own changes in the same session.

Why is this considered an architectural anti-pattern?

The reviewer retains the reasoning context from the code generation phase, creating confirmation bias and reducing the likelihood of catching subtle issues.

It exceeds the maximum token limit for the context window, causing the session to silently truncate the generated code.

Same-session reviews trigger rate limiting automatically, breaking the CI/CD pipeline.

The Message Batches API does not support multi-turn tool calling within a single request.

5. While configuring prompt engineering standards for a production application, you must decide when to implement few-shot examples.

Which of the following scenarios represent the most effective use cases for few-shot prompting? Choose 2 correct answers.

Ambiguous classification tasks where the boundaries between categories are fuzzy or subjective.

Simple, well-defined data extraction tasks with clear objective criteria.

Tasks requiring standard output formats like valid JSON, where tool_use is already implemented.

Tasks requiring a custom, non-standard output format that Claude does not handle natively.

6. During a long-running customer support session, the agent repeatedly summarizes the conversation history to save context space. By turn 10, the agent forgets the customer's specific account number and the exact promotional price they were quoted.

How should you redesign the context management to prevent this?

Increase the frequency of progressive summarization to occur every 2 turns instead of 5.

Store the conversation in an external database and run a lexical search query on every turn.

Extract transactional facts into an immutable 'case facts' block positioned at the start of the context that is never summarized.

Restart the session from scratch after 5 turns and ask the customer to repeat their details.

7. A developer is using a multi-agent system to analyze a massive legacy codebase. The coordinator agent is running out of context window space because the search tool returns verbose file contents and exploration noise.

What is the best pattern to mitigate this context degradation?

Share the full coordinator conversation history with all subagents to ensure maximum context propagation.

Delegate the verbose file-by-file exploration to a subagent, which then returns only a synthesized summary of its findings back to the coordinator's context.

Force the coordinator agent to use the Bash tool to run grep manually instead of reading files.

Switch from dynamic adaptive decomposition to static prompt chaining to force a linear review path.

8. When building an agent that queries a backend order system, the lookup_order tool returns a JSON object with 40+ fields, but the age only needs the order status, shipping date, and tracking number.

What context optimization technique should be applied?

Implement a PostToolUse hook to trim the verbose tool outputs, returning only the relevant fields to the agent's context.

Prompt the model to ignore the irrelevant fields after the full JSON object is appended to the conversation history.

Utilize the /compact command immediately after every tool call.

Use a PreToolUse hook to block the tool call entirely and escalate to a human.

9. In a long-running codebase debugging session, the agent makes important intermediate discoveries but starts forgetting earlier constraints as the context window fills.

How can you ensure these intermediate discoveries survive context compression boundaries?

Declare global variables in the system prompt to hold state.

Use the - -resume flag to append the new context to the old session.

Persist critical intermediate state to extemal scratchpad files, which survive session boundaries and context resets.

Apply the 'lost in the middle' effect by placing the discoveries in the exact center of the prompt.

10. You are managing context in a long-running Claude Code session that has accumulated a large amount of exploratory tool calls. You want to free up context space without completely losing the memory of what was previously worked on.

Which techniques are recommended? Choose 2 correct answers.

Use the /compact command to summarize conversation history and reclaim context space.

Use the /clear command to erase all history and rely on the model's pre-trained knowledge.

Save key findings to a scratchpad file and delegate verbose exploration to subagents.

Delete older messages from the conversation array manually to ensure hard truncation.

Page 2 of 10

11. You are reviewing the escalation logs for a customer support agent. The agent currently escalates cases whenever it detects an angry customer tone, even for simple tasks like password resets.

What is the architectural flaw in this escalation design?

Sentiment does not equal task complexity; the agent should escalate based on objective criteria like policy gaps or explicit human requests, not emotion.

The agent should have processed a refund automatically to calm the customer down before escalating.

The sentiment threshold is set too low; it should only escalate if the customer uses specific profanity.

The agent lacks a PreToolUse hook to normalize the customer's text input before processing.

12. To optimize a structured data extraction pipeline, you want to route only the most uncertain documents to your limited pool of human reviewers.

Which method provides the most reliable calibration for this routing?

Relying on the model's self-reported confidence score in the conversational text output.

Routing any document that triggers a validation-retry loop more than once.

Having the model output field-level confidence scores, and calibrating those thresholds using a labeled validation set.

Escalating documents based solely on the aggregate accuracy metric of the entire pipeline.

13. An AI extraction system processes thousands of financial documents. The dashboard displays an impressive 96% overall aggregate accuracy. However, downstream teams complain about frequent errors.

What is the most likely oversight in the review and monitoring design?

The system is using prompt chaining instead of dynamic adaptive decomposition.

Aggregate accuracy metrics can mask severe per-document-type failures (e.g., invoices failing at 70% while receipts succeed at 99%).

The extraction is using JSON schema tool_use which guarantees semantic correctness but fails structural checks.

The system lacks a PostToolUse hook to block large financial transactions.

14. In a multi-agent research system, subagent A retrieves revenue data from a verified financial database, while subagent B extracts conflicting revenue data from an outdated PDF.

How should the system handle this uncertainty before presenting it to a human reviewer?

Silently drop the PDF data and return the database value since databases are always correct.

Average the two values to provide a balanced estimate to the human reviewer.

Maintain structured claim-source mappings with information provenance (source, confidence, timestamp) so the coordinator or human can make an informed resolution.

Restart both subagents using a higher temperature setting to generate a consensus value.

15. When designing an autonomous customer support agent, you must explicitly program the conditions under which it stops attempting to solve the problem and escalates to a human.

Which of the following are valid, objective escalation triggers? Choose 2 correct answers.

The agent detects a policy gap where no existing rule covers the customer's specific situation.

The agent assesses its own confidence level to be below 0.6 out of 1.0.

The customer explicitly demands to speak with a human representative.

The customer expresses high frustration and uses negative sentiment words.

16. When implementing a multi-agent research system for a enterprise application, a coordinator agent must delegate a market analysis task to a specialized subagent.

What is the correct approach for passing context to this subagent?

Share the entire coordinator conversation history to ensure the subagent has maximum context.

Allow the subagent to access a shared global state object where the coordinator writes its findings.

Pass only the specific, explicit context relevant to the subagent's assigned subtask in the prompt.

Use the /compact command to summarize the coordinator history before passing it to the subagent.

17. An agentic loop is the core execution pattern for Claude-based agents.

When building an agent, how should the loop reliably determine when to terminate and return a final response to the user?

Parse the assistant's natural language text output to check for keywords like 'task complete' or 'l am done'.

Set a hard maximum iteration cap of 10 loops to prevent infinite execution and terminate when reached.

Check the stop_reason field of the API response and exit the loop when it equals end_turn.

Monitor the token count of the conversation and stop when it approaches the context window limit.

18. During a tool execution step, your agent's lookup_customer tool fails to connect to the external database due to a timeout.

What is the architecturally correct way to handle this error and propagate it back to Claude?

Return a structured error response with isError: true, specify the error category (e.g., timeout), indicate if it is retryable, and provide context about what was attempted.

Silently return an empty JSON array [J so the agent can smoothly transition to trying an alternative lookup method.

Return a generic string like { "error" : " Operation failed" } to prevent leaking internal database infrastructure details to the LL

Throw a fatal system exception to immediately terminate the agentic loop and trigger a fallback to a human operator.

19. You are deep into a complex codebase analysis session and need to explore an alternative API integration approach without polluting your main session's context window.

Which session management mechanism should you use?

Use the /clear command to reset the context window before exploring.

Use claude fork_session to create a branched session that inherits current context but diverges safely.

Use claude--resume to append the alternative exploration onto a previously saved checkpoint.

Create a scratchpad file and write the alternative approach directly to the local disk.

20. When implementing a hub-and-spoke multi-agent architecture using the Claude Agent SDK, which of the following statements about subagent spawning and execution are correct? Choose 2 correct answers.

The coordinator agent must have Task included in its allowed Tools configuration to spawn subagents.

Subagents automatically inherit the full conversation history of the coordinator agent by default.

A single coordinator response cannot emit multiple Task tool calls; subagents must be spawned sequentially across separate turns.

Parallel execution is achieved when the coordinator agent emits multiple Task tool calls in a single response.

Page 3 of 10

21. A development team wants to enforce TypeScript strict mode, specific ESLint rules, and API design standards for all developers working on a shared repository.

Where is the correct location to configure these team-wide standards in Claude Code?

In the user-level configuration file located at ~/.claude/CLAUD

md.

In the project-level configuration file located at .claude/CLAUD

md or the project root.

In a directory-level configuration file located at src/api/CLAUD

md.

In the .claude/settings.json file under the team_standards array.

22. Claude Code provides several built-in tools for codebase exploration and modification.

If an agent needs to fix a bug on line 42 of an existing, lengthy TypeScript file, which tool should be utilized to ensure unchanged content is safely preserved?

Write, passing the updated content block to rewrite the target file.

Bash, using standard Unix utilities like sed to replace the line.

Edit, providing the old text block and the new text block for targeted replacement.

Glob, searching for the specific line and replacing it via regex.

23. You are integrating Claude Code into a GitHub Actions CI/CD pipeline to automate pull request reviews.

Which flag combination must be used to ensure the process runs without hanging and produces machine-parseable output?

Option A

Option B

Option C

Option D

24. A developer needs to migrate a monolithic application into microservices, requiring changes across 45+ files, updates to module dependencies, and new architectural boundaries.

Which execution approach in Claude Code is recommended for this task?

Use Direct Execution to incrementally modify files one by one until the migration is complete.

Use the /compact command heavily to fit all 45 files into the context window for a single-pass Direct Execution.

Use Plan mode to explore the codebase, map dependencies, and design an implementation strategy before committing to file modifications.

Write a static Prompt Chain that forces the agent to read, refactor, and save each file sequentially.

25. A engineer is creating a reusable custom Skill in. claude/skills/refactor/SKILL.md. The skill requires an isolated context window to avoid polluting the main session with exploration noise, and must be restricted to only reading files (no modifications).

Which frontmatter configurations are required? Choose 2 correct answers.

isolation: true

context: fork

allowed-tools: Read, Grep, Glob

permissions: read-only

26. When orchestrating an agentic workflow using the Claude Agent SDK, you must enforce a strict business rule: the agent is never allowed to issue refunds over $500.

What is the most robust and deterministic method to implement this constraint?

Add a capitalized warning in the system prompt: NEVER process a refund exceeding $500.

Implement a PostToolUse hook that intercepts the process_refund tool inputs, checks the amount, and programmatically blocks execution if it exceeds 500.

Configure the agent's tool_choice parameter to auto so it can decide when a refund is inappropriate.

Provide few-shot examples showing the agent refusing to process a $600 refund.

27. A customer support agent built with the Claude Agent SDK needs to correctly identify when to resolve a case autonomously versus when to trigger human escalation.

Which of the following represents an architectural anti-pattern for triggering escalation?

Escalating when the agent detects a policy gap not covered by its existing knowledge base.

Escalating immediately when the customer explicitly demands to speak to a human representative.

Escalating based on negative customer sentiment or self-reported low model confidence scores.

Escalating when a deterministic programmatic hook blocks a business operation that exceeds the agent's permission limits.

28. Using the @anthropic-ai/claude-agent-sdk, you want to programmatically narrow the set of tools available to a specific query loop to prevent the agent from making unintended modifications.

Which configuration is used to restrict tools in the SDK?

Pass the allowedTooIs: [ " Read, '" ' Glob"] array inside the options object of the query() function.

Inject a permissions: read-only tag into the top-level AgentDefinition.

Set tool choice: "none" to force the model to only use search tools.

Edit the. mcp. j son file to globally disable the write tools for the entire project.

29. When implementing multi-pass review architectures for automated CI/CD pipelines, why is configuring the exact same Claude SDK session to review its newly generated code considered a major anti-pattern?

It causes the token limit of the context window to exceed its maximum capacity.

The Message Batches API does not support synchronous self-review workflows.

Tools invoked in the first pass are permanently locked and cannot be reused in the second pass.

The reviewer retains the reasoning context from the generation phase, creating confirmation bias and reducing the likelihood of catching subtle flaws.

30. When building the raw tool-handling conversation loop with the API/SDK, Claude may return a ToollJse block.

To properly continue the multi-turn agentic loop, what are the requirements for formatting and returning the result of the executed function to Claude? Choose 2 correct answers.

The result must be appended to the messages array inside a user role message containing a tool_result block.

The tool result block must include a that matches the ID generated by Claude's initial tool request.

The result must be passed back inside an assistant role message with an is_error'. false flag.

The tool result must strictly be a serialized JSON object; raw text strings will automatically trigger a loop termination.

Page 4 of 10

31. When implementing a Model Context Protocol (MCP) server, what is the primary architectural purpose of defining an MCP Resource instead of an MCP Tool?

To expose executable functions that perform side-effects or mutations on external backend systems.

To expose data catalogs or static content that can be fetched by the client and injected directly into prompts without requiring the agent to formulate a tool call.

To provide reusable conversation templates consisting of predefined user and assistant messages for the agent.

To manage environment variables and authentication secrets safely across the development team.

32. When using the Claude API, how must a system prompt be formatted to successfully utilize prompt caching?

Provide the system prompt as a standard string and set prompt_caching: true at the top level of the API request.

Structure the system prompt as a dictionary with a text block and include a cache_control field set to {"type": " ephemeral " }

Include the system prompt inside an XML block labeled.

Use the Message Batches API to ensure the system prompt is automatically cached across all batched requests.

33. When streaming responses that include tool calls in the Claude API, why might you observe buffering delays followed by bursts of text?

The API automatically waits for the entire tool output to be generated before streaming begins.

The API is performing a secondary security check on the generated tokens to prevent prompt injection.

The API validates JSON chunks and waits for complete top-level key-value pairs before sending them to the client.

The ContentBlockDelta events are rate-limited to 10 events per second.

34. Where should a development team configure a shared Jira MCP server to ensure credentials are NOT leaked in version control?

In the user-level 4. claude. json file, requiring each team member to manually script the configuration.

In the project-level .mcp.json file, using environment variable expansion syntax like

Inside a dedicated secrets. json file that is committed to the repository.

As inline comments within the CLAUD

md file.

35. Using the FastMCP Python SDK, which decorators are used to expose capabilities to an MCP client? Choose 2 correct answers.

@mcp.tool

@mcp.agent

@mcp.action

@mcp.resource

36. You are building a customer support resolution agent using the Claude Agent SDK. The agent is currently escalating simple requests like password resets if the customer uses angry language.

How should you fix this escalation logic?

Lower the sentiment analysis threshold so that the agent only escalates if explicit profanity is detected.

Implement escalation based on objective criteria such as policy gaps, capability limits, or explicit human requests, rather than customer sentiment.

Issue an automatic partial refund to calm the customer down before processing the password reset.

Use a PreToolUse hook to normalize the customer's text input to a neutral tone before Claude processes it.

37. Your customer support agent needs a strict limit preventing it from processing refunds exceeding $500.

What is the most deterministic architectural method to enforce this?

Add a capitalized warning in the system prompt: 'NEVER process a refund exceeding $500.'

Provide several few-shot examples in the prompt showing the agent successfully refusing high-value refunds.

Set the tool_choice parameter to 'auto' so the model can dynamically reject the action.

Implement a PostToolUse hook to intercept the process_refund tool call and block it programmatically if the amount exceeds 500.

38. The agent attempts to call a lookup_order tool, but the backend database is down due to a timeout.

What structured error response should the tool return to the agent?

An empty JSON array [J so the agent can smoothly transition to an alternative tool.

A structured object containing isError: true, an error category of 'timeout', isRetryab1e: true, and context of what was attempted.

A generic string " Operation failed"} to avoid leaking infrastructure details to the LL

{"error: " A fatal exception that immediately terminates the agentic loop.

39. During a long-running customer support session, critical details like the customer's account number and order amount are lost due to progressive summarization.

What architectural pattern prevents this context degradation?

Increase the frequency of the summarization algorithm to trigger every 3 turns.

Restart the session entirely and require the user to input their context again.

Store critical transactional details in an immutable 'case facts' block positioned at the beginning of the context window.

Write all customer details to an external database and run a lexical search on every turn.

40. When designing escalation patterns for an autonomous customer support agent, which of the following represent architectural anti- patterns that should be avoided? Choose 2 correct answers.

Relying on the model's self-reported confidence score to determine if human review is needed.

Escalating cases immediately when a customer explicitly requests to speak to a human.

Escalating cases automatically based on high levels of negative customer sentiment.

Escalating cases when the agent detects a policy gap not covered by its instructions.

Page 5 of 10

41. A engineering team wants to share formatting rules, testing guidelines, and preferred libraries across their entire repository.

Where is the correct location to configure these team-wide standards in Claude Code?

In the user-level configuration file located at ~/. claude/CLAUD

md.

In the project-level configuration file located at. claude/CLAUD

md or the project root.

In a directory-level configuration file located at tests/CLAlJD

md.

In the global .mcp.json file.

42. You are assigned to restructure a monolithic application into microservices, requiring architectural decisions and changes across 45+ files.

Which execution approach in Claude Code is recommended?

Start with direct execution and make changes incrementally, letting the implementation reveal the natural boundaries.

Use direct execution with a massive upfront prompt detailing how every service should be structured.

Enter plan mode to explore the codebase and design an implementation strategy before executing changes.

Write a static Prompt Chain that forces the agent to read and refactor each file sequentially.

43. Your project has React components, API handlers, and database models. Test files are spread throughout the codebase next to the code they test.

How can you ensure Claude automatically applies the correct testing conventions when generating code?

Consolidate all conventions in the root CLAUD

md file and rely on Claude to infer the correct section.

Create rule files in. claude/rules/with YAML frontmatter specifying glob patterns like **/*. test.tsx.

Create an MCP server that injects testing rules into the prompt manually.

Place a separate CLAUD

md file in each subdirectory containing test-specific conventions.

44. You need to create a reusable behavior for complex refactoring.

To prevent the exploration noise from polluting the main session's context window, which configuration should you use in your SKILL. md?

Set context: fork in the YAML frontmatter.

Set isolation: true in the YAML frontmatter.

Add the /compact command at the end of the skill's instructions.

Use a standard custom command in. claude/commands/instead of a skill.

45. When using Claude Code for continuous integration (CI) and multi-pass code review workflows, which of the following practices are highly recommended? Choose 2 correct answers.

Use the -p flag to ensure non-interactive execution so the pipeline does not hang.

Have the same session that generated the code review its own changes to ensure maximum context preservation.

Isolate the code generator session from the code reviewer session to eliminate confirmation bias.

Use the Message Batches API to process blocking pre-merge pull request checks.

46. When designing a multi-agent research system for a enterprise application, which architectural pattern is recommended to manage parallel research tasks effectively?

A flat architecture where all agents share a global state and full conversation history to maximize context visibility.

A hub-and-spoke architecture where a central coordinator delegates tasks to specialized subagents with isolated contexts.

A sequential pipeline architecture where each agent passes its entire context and output directly to the next agent in the chain.

A monolithic architecture utilizing a single agent loaded with all available research and synthesis tools.

47. In a coordinator-subagent research system, a web search subagent times out while attempting to retrieve information on a complex topic.

How should this failure be propagated back to the coordinator agent?

The subagent should catch the timeout and return an empty JSON array L] marked as successful so the workflow continues smoothly.

Propagate the timeout exception directly to a top-level handler to immediately terminate the entire research workflow.

Implement automatic retry logic indefinitely within the subagent, returning a generic search unavailable status if it ultimately fails.

Return structured error context to the coordinator, including the failure type, the attempted query, any partial results, and potential alternative approaches.

48. When the coordinator agent delegates a subtask to a specialized document analysis subagent, what is the best practice for passing context to ensure optimal performance?

Share the full coordinator conversation history with the subagent so it has the maximum possible context.

Pass ONLY the explicit context and findings relevant to that specific subagent's assigned task.

Grant the subagent access to the coordinator's scratchpad file using a Read tool.

Use the /compact command to summarize the coordinator's history before injecting it into the subagent's context.

49. During the final synthesis phase, the system receives conflicting statistical data from two different subagents: one derived from a verified financial database, and another extracted from an outdated PDF.

How should the synthesis agent handle this conflict?

Arbitrarily select the value from the financial database since structured databases are inherently more accurate.

Average the two conflicting values together to provide a balanced estimate in the final report.

Track information provenance by preserving both values, their sources, confidence levels, and timestamps, allowing informed resolution.

Halt the synthesis process and prompt the user to manually select the correct statistical value.

50. When building a multi-agent research pipeline using the Claude Agent SDK, which of the following practices represent architectural anti- patterns that must be avoided? Choose 2 correct answers.

Silently returning empty result sets for failed API lookups instead of reporting access failures.

Using a flat architecture where all agents share a global state and full conversation history.

Emitting multiple Task tool calls in a single coordinator response to execute subagents in parallel.

Requiring subagents to output structured claim-source mappings to preserve attribution.

Page 6 of 10

51. A developer grants a single Claude agent access to 18 different tools for a complex refactoring task. Production logs indicate that the agent frequently selects the wrong tool.

What is the most effective architectural fix for this issue?

Expand the tool descriptions to include more exhaustive examples and edge cases for all 18 tools.

Reduce the number of tools per agent to 4-5 by distributing the rest across specialized subagents.

Implement a routing layer that pre-selects tools based on keyword matching in the user's prompt.

Switch to a higher-tier model with a larger context window to better process the 18 tool schemas.

52. When configuring a project-level Jira Model Context Protocol (MCP) server for a development team, what is the required method for securely managing authentication credentials?

Hardcode the API tokens directly in the .mcp.json file to ensure all team members can access the integration.

Configure the server in the user-scoped ~/. claude. json file so credentials remain local to each developer.

Define the server in the project-scoped .mcp.json file using environment variable expansion like ${JIRA_TOKEN}.

Store the credentials in an encrypted secrets .json file referenced by the CLAUD

md configuration.

53. An agent needs to modify a specific configuration value on line 42 of a large, existing 800-line TypeScript file.

Which built-in tool should be utilized to perform this action safely?

The Write tool, providing the complete 800-line file content with the modified value.

The Bash tool, using Unix utilities like sed or awk to replace the string.

The Edit tool, using targeted old text and new text matching to preserve unchanged content.

The Grep tool, combined with a regex replace command.

54. A developer asks the agent to 'read the project configuration file to determine the database connection string'.

Which built-in tool represents the correct architectural choice for this task?

"database", "config. j son

Bash("cat config. j son")

Grep( Glob ( " config. j son ")

Read (" config. j son

55. When utilizing Claude Code's built-in tools for codebase exploration and modification, which of the following usages represent correct tool selections? Choose 2 correct answers.

Using Grep to search for all occurrences of a deprecated function name across the src/directory.

Using Glob to find all file paths that end in .test.tsx within the project.

Using Write to fix a minor typo in an existing, heavily documented configuration file.

Using Bash to execute find. "-name * .ts" to locate all TypeScript files.

56. You are tasked with integrating Claude Code into a Continuous Integration (CI) pipeline to run an automated security analysis on pull requests.

Which execution flag must be included to ensure the automated job does not hang indefinitely?

Option A

Option B

Option C

Option D

57. To optimize a CI/CD pipeline, your manager wants to use the Message Batches API to reduce costs by 50%. The pipeline includes a real-time, blocking pre-merge code review, and a separate nightly technical debt audit.

How should you apply the Batch API?

Use the Batch API for both workflows to maximize cost savings, utilizing status polling for the pre-merge check.

Use synchronous API calls for both workflows, as the Batch API does not support structured JSON schema outputs.

Use the Batch API strictly for the nightly technical debt audit, and retain synchronous real-time calls for the blocking pre-merge review.

Switch both to the Batch API, but implement a timeout fallback that switches to synchronous calls if the batch exceeds 5 minutes.

58. In an automated code review workflow, why is it considered a major architectural anti-pattern to have the same Claude session both generate code and subsequently review its own generated changes?

It exceeds the maximum token limits for the context window during the generation phase.

The reviewer retains the reasoning context and assumptions from the generation phase, creating confirmation bias.

The Message Batches API does not support multi-turn tool calling within a single request.

Tools invoked during the first pass are permanently locked and cannot be reused in the review pass.

59. Your CI pipeline must consume Claude's code review feedback programmatically to post inline comments on a GitHub pull request.

How should you enforce the exact structural shape of the output?

Use regex to parse the unstructured markdown text output returned by Claude.

Add - -output-format json and supply the required structure via the --json-schema CLI flag.

Inject a PostToolUse hook that formats the text output into a JSON object.

Provide at least 10 few-shot examples of valid JSON structures in the system prompt.

60. When integrating Claude Code into continuous integration and delivery pipelines, which of the following practices are highly recommended for reliability and automation? Choose 2 correct answers.

Executing Claude Code using the -p flag to ensure the process runs non-interactively.

Having the same session that generated the code perform the final review to ensure context consistency.

Isolating the code generator session from the code reviewer session to eliminate confirmation bias.

Using the Message Batches API to execute blocking pre-merge pull request checks to save costs.

Page 7 of 10

61. When implementing a structured data extraction pipeline using tool_use and JSON schemas, what exactly does the tool use mechanism guarantee?

Both structural compliance and semantic correctness of the extracted data.

Structural compliance only, requiring separate validation for semantic accuracy.

Automatic retry and self-correction whenever a required field is missing.

Elimination of hallucinations by forcing the model to strictly quote the source document.

62. During data extraction, a semantic validation check fails because the extracted line items do not sum to the total invoice amount.

What is the recommended best practice for implementing the validation-retry loop?

Send a generic retry message such as 'There were errors in your extraction. Please try again.' to reset the model's reasoning.

Append specific validation error details to the prompt, stating which field failed and the nature of the discrepancy.

Increase the max_tokens limit on the retry request to give the model more space to self-correct.

Rely entirely on the model's self-reported confidence scores to automatically adjust the extraction.

63. The data extraction system needs to categorize document types using an enum schema field. However, new and unexpected document types occasionally appear in production.

How should you design the schema to handle this ambiguity?

Use a rigid enum containing only known document types to force the model to pick the closest match.

Use an open-ended string field instead of an enum to maximize flexibility.

Include an 'other' enum value paired with a 'document_type_detail' string field, guided by 2-4 few-shot examples covering edge cases.

Deploy a PreToolUse hook to intercept and reject any document types not pre-configured in the schema.

64. Your automated extraction pipeline displays an impressive 96% aggregate accuracy on the dashboard. However, downstream teams complain about frequent errors when processing complex financial contracts.

What monitoring methodology resolves this visibility gap?

Tracking accuracy per document type and field (stratified metrics) instead of relying solely on aggregate metrics.

Increasing the overall sampling size randomly to capture a broader dataset.

Switching entirely to the Message Batches API to ensure complete asynchronous processing.

Utilizing fork_session to isolate contract documents into separate evaluation workflows.

65. When designing JSON schemas for an extraction tool, why is it considered a best practice to define certain fields as optional or nullable (e.g., ["string’,' "null " J)? Choose 2 correct answers.

To prevent the model from fabricating or hallucinating values when the requested information is absent from the source document.

To ensure structural compliance without forcing the model to guess unknown values to satisfy required field constraints.

To trigger an automatic retry loop whenever the model returns a null value.

To bypass the tool_choice: " any" parameter constraint during execution.

66. When implementing an agentic loop using the Claude API, what is the only architecturally reliable signal to determine whether the loop should terminate or continue executing?

Parsing the assistant's natural language text output for completion keywords like 'task complete'.

Inspecting the stop_reason field of the API response for tool_use versus end_turn.

Implementing a hard maximum iteration cap of 5 loops to prevent infinite execution.

Monitoring the total token count and exiting when it reaches the context window limit.

67. A customer support agent must never process a refund exceeding $500 without explicit manager approval.

What is the most robust and deterministic method to enforce this business rule?

Include a capitalized warning in the system prompt explicitly forbidding refunds over $500.

Provide negative few-shot examples in the prompt showing the agent successfully refusing high-value refunds.

Implement a PostToolUse hook that programmatically intercepts the refund tool call and blocks execution if the amount exceeds 500.

Set the tool choice parameter to 'auto' so the model can dynamically assess the financial risk.

68. You are analyzing a massive legacy codebase and want to explore an alternative, potentially destructive refactoring approach without polluting your main session's context window.

Which session management feature should you use?

- resume

fork session

/compact

/clear

69. When orchestrating complex workflows, you must decide between prompt chaining (fixed sequential pipelines) and dynamic adaptive decomposition.

In which scenario is dynamic adaptive decomposition the preferred architectural choice?

When conducting predictable, multi-aspect code reviews where the sequence of analysis is static.

When executing an open-ended investigation task where intermediate discoveries dictate the next required steps.

When applying deterministic compliance policies to financial transaction requests.

When extracting structured JSON data from standardized invoice templates.

70. Which of the following scenarios describe valid and effective uses of Agent SDK hooks (such as PreToolUse and PostToolUse)? Choose 2 correct answers.

Intercepting tool results to normalize heterogeneous data formats (like dates or status codes) before the model processes them.

Guaranteeing that a generated JSON object contains no semantic reasoning errors.

Intercepting outgoing tool calls to block policy-violating actions and redirecting to human escalation workflows.

Controlling the total number of subagents that can be spawned simultaneously during multi-agent orchestration.

Page 8 of 10

71. In a hub-and-spoke multi-agent architecture, what is the best practice for passing context from the coordinator agent down to a specialized subagent?

Share the entire coordinator conversation history to ensure the subagent has maximum context.

Pass only the explicit context, findings, and parameters specifically relevant to that subagent's assigned subtask.

Grant the subagent access to a shared global state object where the coordinator writes its findings.

Subagents automatically inherit the coordinator's full context window, so no explicit passing is needed.

72. A subagent attempts to query an external database but encounters a timeout.

How should this error be propagated back to the coordinator agent?

The subagent should silently return an empty JSON array to allow the workflow to proceed smoothly.

Return a generic 'Operation failed' string to prevent leaking infrastructure details.

Return structured error context, including the failure type (access failure), what was attempted, and partial results.

Throw a fatal exception to immediately terminate the entire research workflow.

73. During a multi-agent synthesis phase, the coordinator receives conflicting financial statistics from a web search subagent and a document analysis subagent.

What is the required architectural pattern for handling this conflict?

Arbitrarily select the value from the document subagent, as internal documents are generally more reliable.

Average the two conflicting values together to provide a balanced estimate.

Maintain structured claim-source mappings to preserve information provenance (source, confidence, timestamp) allowing for an informed resolution.

Discard both values and prompt the user to manually input the correct statistic.

74. What configuration is strictly required for a coordinator agent to be able to spawn subagents?

The tool_choice parameter must be set to 'auto'.

The coordinator's allowedTools array must explicitly include the Task tool.

The agent must be executed in plan mode rather than direct execution.

A PreToolUse hook must be registered to manage process limits.

75. Which of the following statements represent correct principles of multi-agent orchestration design? Choose 2 correct answers.

Parallel execution of subagents is achieved by emitting multiple Task tool calls in a single coordinator response.

A flat architecture where all agents share a global state is generally preferred over a hub-and-spoke architecture.

The coordinator should route all inter-subagent communication to maintain observability and consistent error handling.

Subagents should automatically inherit the coordinator's memory across invocations to save token costs.

76. To allow a coordinator agent to spawn specialized subagents in a multi-agent orchestration setup, which specific configuration must be applied to the coordinator?

Set the tool_choice parameter to auto for the coordinator agent.

The coordinator's allowedTools array must explicitly include the Task tool.

The subagent must be initialized with an inherit_context: true flag.

Configure a PreToolUse hook to automatically manage the spawning process.

77. When a subagent encounters a timeout while querying an external database, what is the best practice for propagating this failure back to the coordinator agent?

Return a generic 'search unavailable' string to avoid leaking infrastructure details to the LL

Catch the timeout and silently return an empty array [ ] marked as successful so the workflow continues smoothly.

Return structured error context including the failure type, the attempted query, and partial results so the coordinator can make an intelligent recovery decision.

Terminate the subagent process immediately and throw a fatal system exception to the top-level handler.

78. A developer is designing a hub-and-spoke multi-agent system.

How should context be passed from the coordinator down to a newly spawned subagent?

The subagent automatically inherits the coordinator's full conversation history by default.

Provide the coordinator's complete context window inside the Task tool prompt for maximum context visibility.

Pass ONLY the explicit context, findings, and parameters specifically relevant to the subagent's assigned subtask.

Write all context to a shared scratchpad file that all agents read globally before executing their turns.

79. How can a coordinator agent effectively execute multiple subagents in parallel to speed up a complex research task?

By emitting multiple Task tool calls within a single response turn.

By invoking the parallel_execute method provided natively in the Agent SD

By using the fork_session command for each subagent sequentially.

By setting the concurrency frontmatter field to a value greater than 1.

80. When designing subagents to handle conflicting data from different sources during the final synthesis phase, which of the following are recommended practices? Choose 2 correct answers.

Silently average the conflicting numerical values to provide a balanced estimate.

Require subagents to output structured claim-source mappings.

Preserve information provenance including the source, confidence level, and timestamp.

Arbitrarily select the value from the most recently updated database to resolve the conflict.

Page 9 of 10

81. What is the only reliable and architecturally correct signal in the Claude API to determine whether an agentic loop should continue executing tools or terminate?

Parsing the assistant's natural language text output for completion keywords like 'task complete'.

Inspecting the stop_reason field of the response for tool_use versus end_turn.

Monitoring the total token count and exiting the loop when it reaches the context window limit.

Setting a hard maximum iteration cap of 5 loops to prevent infinite execution.

82. A application features a tool designed to fetch a user's profile. During execution, the tool fails to connect to the database due to a timeout.

Why is silently returning an empty array [ ] in this scenario considered a catastrophic anti-pattern?

It prevents the use of few-shot prompting in the next iteration.

It causes the agent to misinterpret an access failure (could not check) as a valid empty result, wrongly concluding the user does not exist.

It forces the model to ignore all subsequent tool calls in the session.

It causes the Claude API to throw a 400 Bad Request error due to missing required schema fields.

83. To ensure an agent strictly outputs a specific JSON structure without generating conversational text, and guarantees that a specific tool is invoked, which tool_choice configuration is required?

Option A

Option B

Option C

Option D

84. When allocating tools to agents in a multi-agent system, what is the architectural impact of giving a single agent access to an excessive number of tools (e.g., 18 tools)?

The agent automatically splits itself into multiple subagents to handle the load.

Tool selection reliability degrades significantly due to increased decision complexity and ambiguity among similar tools.

The Claude API enforces a hard limit and rejects requests with more than 10 tools.

The model's temperature automatically drops to 0.0 to compensate for the large tool space.

85. An architect is designing an MCP tool that occasionally fails due to downstream rate limits.

Which fields should be included in a well- designed structured error response to help the agent recover? Choose 2 correct answers.

isError: true

system_prompt_override

isRetryable: true

temperature _ adjustment

86. You need to deterministically block any refund transaction that exceeds $500, escalating it to a human instead.

What is the architecturally correct method to enforce this critical business rule using the Agent SDK?

Add a strong, capitalized warning in the agent's system prompt forbidding refunds over $500.

Provide 5 negative few-shot examples showing the agent successfully refusing high-value refunds.

Implement a hook (e.g., PostToolUse or PreToolUse) to programmatically intercept and block the tool call execution.

Set the agent's tool_choice parameter to auto so it can assess the financial risk dynamically.

87. What is the primary architectural difference between enforcing a business rule via a system prompt versus using an Agent SDK hook?

Prompts execute after the tool runs, while hooks execute before the prompt is processed.

Prompts are deterministic, while hooks rely on the model's probabilistic reasoning.

Hooks provide 100% reliable deterministic enforcement, whereas prompts are probabilistic and can occasionally be ignored by the LL

Prompts require an active MCP server connection, while hooks run strictly within the Claude desktop application.

88. When using a hook to normalize heterogeneous data formats (e.g., standardizing different date formats returned by multiple external APIs) before the LLM processes them, which hook pattern is typically used?

A PreToolUse hook that modifies the user's prompt.

A PostToolUse hook that intercepts and transforms the tool results.

A Notification hook that alerts the user of data inconsistencies.

A SubagentStop hook that triggers re-evaluation.

89. An automated pipeline is using a PreToolUse hook to block unauthorized file reads by evaluating the requested file path.

How does the hook command properly communicate to Claude *why* the action was blocked so the agent can adjust its behavior?

By returning an exit code of 2 and writing the explanation to standard error, which is fed back to Claude as feedback.

By silently terminating the session and initiating a new one with an updated system prompt.

By overriding the context window entirely with a generic access denied template.

By returning an empty JSON array [] on standard output.

90. Which of the following scenarios represent architecturally appropriate use cases for implementing hooks in a production Claude application? Choose 2 correct answers.

Normalizing tool outputs, such as date formats or status codes, before they are appended to the context window.

Guaranteeing that an extracted JSON object has no semantic reasoning errors.

Ensuring Claude maintains a conversational and friendly tone with customers.

Intercepting tool calls to deterministically block policy-violating actions before they execute.

Page 10 of 10

91. When configuring Claude Code for a new project, you want to establish team-wide TypeScript strict mode conventions, while keeping your personal Vim keybindings private.

What is the correct architectural approach?

Option A

Option B

Option C

Option D

92. Your application has test files spread throughout the codebase next to the components they test. You want Claude to automatically apply specific testing conventions whenever it generates or edits a test file.

Which configuration method is most maintainable and deterministic?

Consolidate all testing conventions in the root CLAUD

md and rely on Claude's inference to apply them.

Create a rule file in. claude/rules/testing.md With YAML frontmatter specifying paths: [. test. tsx"].

Place a separate CLAUD

md file in every subdirectory that contains test files.

Define an MCP server resource to fetch testing standards dynamically.

93. To maintain a clean and modular configuration, you want to split a monolithic CLAUDE.md file into distinct, topic-specific rule files.

How can you include these external rule files into your main project configuration?

Option A

Option B

Option C

Option D

94. When planning complex multi-flle architectural changes, such as a monolith-to-microservices migration, why is it recommended to use plan mode rather than direct execution?

Plan mode automatically generates missing unit tests for legacy code before executing.

Plan mode utilizes the Message Batches API to reduce token costs by 50 percent.

Plan mode restricts Claude to using only read-only tools to explore the codebase, design a strategy, and get developer approval before making costly modifications.

Plan mode overrides the token limit context window by executing across multiple continuous sessions automatically.

95. The configuration hierarchy in Claude Code resolves settings from multiple levels.

Which of the following are valid configuration layers where CLAUDE.md files can be placed? Choose 2 correct answers.

User-level (e.g., 4. claude/CLAUD

md) for personal preferences.

Global system-level (e.g., /etc/c1aude/CLAl_JD

md) for machine-wide mandates.

Directory-level (e.g., src/api/CLAUD

md) for module-scoped conventions.

Cloud-level (e.g., s3 : //config/CLAUD

md) for distributed synchronization.

96. You are creating a reusable skill for an automated code review process. You want the skill to analyze the codebase extensively without polluting the main conversation's context window with its exploratory output.

Which frontmatter configuration is required?

isolation: true

context: fork

sandbox: enabled

execution_mode: background

CCAR-F Claude Certified Architect – Foundations Exam Preparation Resources

CCAR-F Claude Certified Architect – Foundations Exam Preparation Resources

Share this post

Leave a Reply Cancel reply

Related Posts

CCA-F Claude Certified Architect Foundations Exam Preparation Resources