CCA-F Practice Questions — Page 15

Question 141

Scenario: Developer Productivity Tools

A long exploration session has filled the context with verbose tool output, and you want to keep working without starting over. A teammate warns that this operation has a known trade-off.

Which statement about `/compact` is correct?

A.`/compact` losslessly stores the full history to disk and reloads it on demand.
B.`/compact` summarizes prior history to free context, but exact numbers, dates, and specific details can be lost in summarization.
C.`/compact` permanently deletes the conversation and begins a brand-new session.
D.`/compact` increases the model's context-window size for the rest of the session.

Question 142

Open question ↗

Scenario: Developer Productivity Tools

An agent answering questions about a large project-management dataset (all tasks, hierarchy, statuses) makes 8–10 exploratory tool calls per question just to learn what data exists, burning context before it even starts answering.

Which MCP capability removes the exploratory calls?

A.Expose the catalog/schema as an MCP resource the agent can read for an immediate map of the available data.
B.Add a dedicated tool for each kind of exploratory question.
C.Increase `max_tokens` so the exploratory calls fit in context.
D.Force `tool_choice: "any"` to make exploration happen faster.

Question 143

Open question ↗

Scenario: Developer Productivity Tools

A crash report includes a clear stack trace pointing to a single missing null-check in one helper file. The cause is obvious and the fix is a two-line guard.

What is the appropriate workflow?

A.Planning mode with a full codebase exploration before touching anything.
B.Fork the session to compare two different ways of adding the null check.
C.Direct execution — the change is small, well understood, and confined to one file.
D.Spawn an Explore subagent to map the whole module before applying the fix.

Question 144

Open question ↗

Scenario: Developer Productivity Tools

Eight hours into investigating a sprawling monolith, the agent's responses become unstable — it contradicts an earlier finding and starts describing "common architectures" rather than the actual modules. You still need accurate, specific answers about the code.

What is the best way to keep the investigation reliable?

A.Keep everything in one ever-growing context so nothing is forgotten.
B.Raise `max_tokens` so the model can hold more detail per response.
C.Tell the model to try harder and be more specific in its answers.
D.Summarize key findings to a scratchpad, then spawn focused subagents for specific questions while the main agent coordinates.

Question 145

Open question ↗

Scenario: Developer Productivity Tools

To understand how `calculateInvoiceTotal` is used, you need to find every call site and then trace the data flow through a couple of wrapper modules in an unfamiliar billing service.

What is the most effective approach?

A.Read every file in the service top-to-bottom until you encounter the function.
B.Grep for the function name to find entry points and call sites, then Read those files to trace the flow through the wrappers.
C.Use Glob to search file contents for the function usages.
D.Ask the model to guess the likely call sites from the function name alone.

Question 146

Open question ↗

Scenario: Developer Productivity Tools

You want to try an experimental MCP server on your own machine while you evaluate it. It should not be shared with the team or committed to the repository.

Where should this server be configured?

A.In your user-level `~/.claude.json`, which is personal and not shared via version control.
B.In the project's `.mcp.json`, which is committed and shared with everyone.
C.In the root `CLAUDE.md` so it loads on every turn.
D.In a `.claude/config.json` file at the repo root.

Question 147

Open question ↗

Scenario: Developer Productivity Tools

After completing a shared investigation of a codebase, you want to compare two implementation strategies — an event-bus approach and a direct-call approach — each starting from the same understood state and then diverging independently.

Which session feature is designed for this?

A.`--resume`, run twice against the same session name.
B.`/compact`, to split the context into two halves.
C.`fork_session`, which branches independent lines of work from a shared context point.
D.`/memory`, to store both approaches in CLAUDE.md.

Question 148

Open question ↗

Scenario: Developer Productivity Tools

Your team needs to integrate a widely used issue-tracker into Claude Code. An engineer proposes spending a sprint writing a custom MCP server from scratch, even though a well-maintained community server already covers the integration.

What is the recommended approach?

A.Always build a custom MCP server so you control every line of code.
B.Wrap the tracker's REST API in ad-hoc Bash scripts instead of using MCP.
C.Embed the integration logic directly in CLAUDE.md as prose instructions.
D.Prefer the maintained community MCP server for the standard integration rather than building a custom one.

Question 149

Open question ↗

Scenario: Developer Productivity Tools

The team wants a shared GitHub MCP server available to everyone who clones the repo, but the access token must never be committed to version control.

How should this be configured?

A.Add the server to `~/.claude.json` on each developer's machine with the token hard-coded.
B.Add the server to the project `.mcp.json` and reference the token via an environment variable like `${GITHUB_TOKEN}`.
C.Paste the raw token directly into `.mcp.json` and commit it.
D.Put the server config and token in the root CLAUDE.md so the team can see it.

Question 150

Open question ↗

Scenario: Developer Productivity Tools

You must add automated tests to an unfamiliar legacy module. You don't yet know how many files lack coverage or what their dependencies are; each thing you discover changes what to look at next.

Which decomposition strategy fits best?

A.Dynamic adaptive decomposition: map the structure first, then generate a prioritized list of subtasks based on what is discovered.
B.A fixed prompt-chaining pipeline applying the same predefined steps to every file.
C.Spawn one subagent per file up front, before knowing which files even exist.
D.A single prompt asking Claude to write all tests for the whole module at once.