CCA-F Practice Questions — Page 2

Question 11

Scenario: Multi-agent Research System

While researching a broad topic, you observe that the web-search agent and the document analysis agent investigate the same subtopics, leading to substantial duplication in their outputs. Token usage nearly doubles without a proportional increase in research breadth or depth. What is the most effective way to address this?

What is the most effective way to address this?

A.Allow both agents to finish in parallel, then have the coordinator deduplicate overlapping results before passing them to the synthesis agent.
B.The coordinator explicitly partitions the research space before delegating, assigning each agent distinct subtopics or source types.
C.Implement a shared-state mechanism where agents log their current focus area so other agents can dynamically avoid duplication during execution.
D.Switch to sequential execution where document analysis runs only after web search completes, using web-search results as context to avoid duplication.

Question 12

Open question ↗

Scenario: Multi-agent Research System

During research, the web-search subagent queries three source categories with different outcomes: academic databases return 15 relevant papers, industry reports return “0 results,” and patent databases return “Connection timeout.” When designing error propagation to the coordinator, which approach enables the best recovery decisions?

Which approach enables the best recovery decisions?

A.Aggregate the results into a single success-percentage metric (e.g., “67% source coverage”) with detailed logs available on demand.
B.Report both “timeout” and “0 results” as failures requiring coordinator intervention.
C.Retry transient failures internally and report only persistent errors.
D.Distinguish access failures (timeout) that require a retry decision from valid empty results (“0 results”) that represent successful queries.

Question 13

Open question ↗

Scenario: Multi-agent Research System

Production monitoring shows inconsistent synthesis quality. When aggregated results are ~75K tokens, the synthesis agent reliably cites information from the first 15K tokens (web-search headlines/snippets) and the last 10K tokens (document analysis conclusions), but often misses critical findings in the middle 50K tokens—even when they directly answer the research question. How should you restructure the aggregated input?

How should you restructure the aggregated input?

A.Summarize all subagent outputs to under 20K tokens before aggregation to keep content within the model’s reliable processing range.
B.Stream subagent results to the synthesis agent incrementally, processing web-search results first to completion, then adding document analysis results.
C.Place a key-findings summary at the start of the aggregated input and organize detailed results with explicit section headings for easier navigation.
D.Implement rotation that alternates which subagent’s results appear first across research tasks to ensure both sources get equal top positioning over time.

Question 14

Open question ↗

Scenario: Multi-agent Research System

In testing, the combined output of the web-search agent (85K tokens including page content) and the document analysis agent (70K tokens including chains of thought) totals 155K tokens, but the synthesis agent performs best with inputs under 50K tokens. Which solution is most effective?

Which solution is most effective?

A.Modify upstream agents to return structured data (key facts, quotes, relevance scores) instead of verbose content and reasoning.
B.Add an intermediate summarization agent that condenses findings before passing them to synthesis.
C.Have the synthesis agent process findings in sequential batches, maintaining state between calls.
D.Store findings in a vector database and give the synthesis agent search tools to query during its work.

Question 15

Open question ↗

Scenario: Multi-agent Research System

In testing, you observe that the synthesis agent often needs to verify specific claims while merging results. Currently, when verification is needed, the synthesis agent returns control to the coordinator, which calls the web-search agent and then re-invokes synthesis with the results. This adds 2–3 extra loops per task and increases latency by 40%. Your assessment shows 85% of these verifications are simple fact checks (dates, names, stats) and 15% require deeper research. Which approach most effectively reduces overhead while preserving system reliability?

Which approach is most effective?

A.Give the synthesis agent access to all web-search tools so it can handle any verification need directly without coordinator loops.
B.Have the synthesis agent accumulate all verification needs and return them as a batch to the coordinator at the end, which then sends them all to the web-search agent at once.
C.Have the web-search agent proactively cache extra context around each source during initial research in anticipation of synthesis needing verification.
D.Give the synthesis agent a limited-scope `verify_fact` tool for simple checks, while routing complex verifications through the coordinator to the web-search agent.

Question 16

Open question ↗

Scenario: Claude Code for Continuous Integration

Your CI pipeline runs the Claude Code CLI (in `--print` mode) using CLAUDE.md to provide project context for code review, and developers generally find the reviews substantive. However, they report that integrating findings into the workflow is difficult—Claude outputs narrative paragraphs that must be manually copied into PR comments. The team wants to automatically post each finding as a separate inline PR comment at the relevant place in code, which requires structured data with file path, line number, severity level, and suggested fix. Which approach is most effective?

Which approach is most effective?

A.Add an “Output Format for Review” section to CLAUDE.md with examples of structured findings so Claude learns the expected format from project context.
B.Use the CLI flags `--output-format json` and `--json-schema` to enforce structured findings, then parse the output to post inline comments via the GitHub API.
C.Include explicit formatting instructions in the review prompt requiring each finding to follow a parseable template like `[FILE:path] [LINE:n] [SEVERITY:level] ...`.
D.Keep narrative review format but add a summarization step that uses Claude to generate a structured JSON summary of findings.

Question 17

Open question ↗

Scenario: Claude Code for Continuous Integration

Your team uses Claude Code for generating code suggestions, but you notice a pattern: non-obvious issues—performance optimizations that break edge cases, cleanups that unexpectedly change behavior—are only caught when another team member reviews the PR. Claude’s reasoning during generation shows it considered these cases but concluded its approach was correct. Which approach directly addresses the root cause of this self-check limitation?

Which approach directly addresses the root cause?

A.Run a second independent instance of Claude Code to review the changes without access to the generator’s reasoning.
B.Enable extended thinking mode for the generation stage to allow more thorough deliberation before producing suggestions.
C.Add explicit self-review instructions to the generation prompt asking Claude to critique its own suggestions before finalizing output.
D.Include full test files and documentation in prompt context so Claude better understands expected behavior during generation.

Question 18

Open question ↗

Scenario: Claude Code for Continuous Integration

Your code review component is iterative: Claude analyzes the changed file, then may request related files (imports, base classes, tests) via tool calls to understand context before providing final feedback. Your application defines a tool that lets Claude request file contents; Claude calls the tool, gets results, and continues analysis. You’re evaluating batch processing to reduce API cost. What is the primary technical limitation when considering batch processing for this workflow?

What is the primary technical limitation?

A.Batch processing does not include correlation IDs to map outputs back to input requests.
B.The asynchronous model cannot execute tools mid-request and return results for Claude to continue analysis.
C.The Batch API does not support tool definitions in request parameters.
D.The batch processing latency of up to 24 hours is too slow for pull request feedback, although the workflow would otherwise function.

Question 19

Open question ↗

Scenario: Claude Code for Continuous Integration

Your CI/CD system runs three Claude-based analyses: (1) fast style checks on every PR that block merging until completion, (2) comprehensive weekly security audits of the entire codebase, and (3) nightly test-case generation for recently changed modules. The Message Batches API offers 50% savings but processing can take up to 24 hours. You want to optimize API cost while maintaining an acceptable developer experience. Which combination correctly matches each task to an API approach?

Which combination is correct?

A.Use the Message Batches API for all three tasks to maximize 50% savings, configuring the pipeline to poll for batch completion.
B.Use synchronous calls for PR style checks; use the Message Batches API for weekly security audits and nightly test generation.
C.Use synchronous calls for all three tasks for consistent response times, relying on prompt caching to reduce costs across workloads.
D.Use synchronous calls for PR style checks and nightly test generation; use the Message Batches API only for weekly security audits.

Question 20

Open question ↗

Scenario: Claude Code for Continuous Integration

Your automated reviews find real issues, but developers report the feedback is not actionable. Findings include phrases like “complex ticket routing logic” or “potential null pointer” without specifying what exactly to change. When you add detailed instructions like “always include concrete fix suggestions,” the model still produces inconsistent output—sometimes detailed, sometimes vague. Which prompting technique most reliably produces consistently actionable feedback?

Which prompting technique is most reliable?

A.Further refine instructions with more explicit requirements for each part of the feedback format (location, issue, severity, proposed fix).
B.Expand the context window to include more surrounding codebase so the model has enough information to propose concrete fixes.
C.Implement a two-pass approach where one prompt identifies issues and a second generates fixes, allowing specialization.
D.Add 3–4 few-shot examples showing the exact required format: identified issue, location in code, concrete fix suggestion.