Question 390
A developer wants Claude Code to use a specialist reviewer with its own instructions and tool restrictions. What customization should be chosen?
- Limit actual tool permissions rather than relying only on Skill text.
- Configure a subagent rather than adding a generic web-search MCP tool.
- Assemble supported built-in and custom tools for actions with instructions for orchestration.
- Employ an appropriate built-in tool when its features and permissions meet the task.
Explanation
Correct Answer
B:A subagent creates an isolated reasoning role, whereas an MCP tool supplies an external capability. Give the specialist its own role-specific prompt and available tools; a generic external search endpoint does not create that role.
Incorrect Answers
A:Tool availability and authorization define what can execute; a procedural document cannot enforce a security boundary; changing executable permission enforcement does not establish specialist agent versus external tool in this application.
C:No single Skill or MCP primitive replaces a complete agent design; each component should match the capability it provides; where specialist agent versus external tool matters, a control for mixed capability composition leaves that test unmet.
D:Built-ins reduce custom integration burden, but their scope must still be controlled; the consequence is improved built-in file tool fit, not verified specialist agent versus external tool.
Question 391
A team adds a Skill containing shell snippets and assumes those snippets automatically execute. What misconception is present?
- A code sample inside a Skill automatically runs when Claude reads the file.
- The Skill’s title grants a new tool capability to the model service.
- Skill content is guidance; execution still requires available authorized tools.
- Documented shell snippets bypass workspace restrictions because they are reusable.
Explanation
Correct Answer
C:Documentation can shape model behavior but does not grant runtime privileges or run commands by itself. The runtime must still grant and mediate any shell or file tools that a model could choose while following the Skill's steps.
Incorrect Answers
A:Reading an instruction asset provides context; it does not itself dispatch a command to a shell executor. An authorized tool call is required for actual execution.
B:Names and descriptions affect discovery but cannot create an authorized backend function. The runtime must expose a real executor for the task.
D:File-system and tool permission boundaries still apply when any snippet is later executed through a tool. The workspace policy remains in effect when tools run.
Question 392
A team decides between built-in tools, Skills, and MCP services. Which THREE mappings are appropriate? Choose THREE.
- Use a Skill to package a repeatable editorial review method.
- Use a Skill as the sole technical permission boundary.
- Use an MCP server for a reusable authenticated connector shared across clients.
- Treat a general-purpose agent as automatically authorized to call every tool.
- Use a supported built-in tool when it already provides the required file operation.
- Deploy a new MCP server solely to remember one wording preference.
Explanation
Correct Answers
A:Skills supply reusable instructions and assets rather than automatically executing external APIs. Reusable editorial instructions belong in a procedure package, while any underlying file edits still require real tools.
C:An MCP server centralizes discovery and protocol access to a capability used by multiple applications. Clients can discover governed operations through a shared protocol while the service enforces authentication and scope.
E:Built-ins can perform existing capabilities without a redundant integration surface. Compare security boundaries before replacing a built-in capability with custom code and another integration point.
Incorrect Answers
B:Instructions cannot replace server-enforced authorization or sandbox permissions. A Skill can describe what should be done but it cannot directly prevent the executor from granting an unsafe permission.
D:Autonomy is not permission; capabilities must be explicitly granted and checked. An agent's planning flexibility must be paired with explicit tool grants and runtime authorization checks.
F:A simple instruction is not an external executable service requiring server deployment. A simple reusable preference does not require a persistent external server process or service authentication.
Question 393
A built-in file tool can read documents but cannot update the organization’s proprietary ticket system. What justifies introducing a narrow custom integration?
- Claim that a written Skill automatically gains permission to update proprietary tickets.
- Ask Claude to describe a ticket update as complete without invoking the ticket system.
- Replace the reliable built-in file reader with a generic remote shell service.
- Add a permission-scoped ticket-update tool for the unsupported action, while retaining the built-in for file reads.
Explanation
Correct Answer
D:Custom integrations are appropriate when a required capability is absent from the built-in toolset. Keeping separate narrow tools avoids giving the assistant unrelated privileges or duplicating existing file operations.
Incorrect Answers
A:Instructions cannot create network connectivity or permissions. The ticketing system still needs an authenticated, implemented operation before the action can occur.
B:Language generation is not confirmation of a business mutation. An authenticated write tool and a verified result are needed to establish that the ticket changed.
C:A shell-based replacement widens the execution surface while discarding a suitable existing capability. It does not address the ticket update with least privilege.
Question 394
A workflow uses a tool to fetch data and then applies a complex decision rubric. Which components should own each responsibility?
- Constrain actual tool permissions rather than relying only on Skill text.
- Use a tool for fetching and a reusable prompt or Skill for rubric application.
- Favor the built-in when it satisfies functionality without extra trust boundaries.
- Adopt the service after checking its permissions, authentication, and tool contracts.
Explanation
Correct Answer
B:Retrieval is an executable integration, while evaluation criteria are instructions; separating them improves testability.
Incorrect Answers
A:Tool availability and authorization define what can execute; a procedural document cannot enforce a security boundary; when the goal is capability versus procedure separation, optimizing executable permission enforcement misses that operational boundary.
C:New server deployments introduce authentication, latency, and maintenance overhead that may not add value; the capability versus procedure separation criterion differs from avoid redundant custom integration; the gap persists.
D:Existing MCP connectivity saves implementation work only when its security and capabilities fit the application; for capability versus procedure separation, this instead manages evaluating existing MCP integration; the requested decision remains unresolved.
Question 395
An MCP client discovers a document resource and later wants to read that specific document again. Which resource identifier should its read operation use?
- Replace the URI with the model’s current temperature parameter.
- Use the published resource URI when issuing the corresponding resource-read request.
- Read a different resource for each request and assume the content is interchangeable.
- Send the document title as an arbitrary tools/call name without a resource identifier.
Explanation
Correct Answer
B:MCP resources have identifiable URIs that clients can discover and use for subsequent reads. The server must resolve the requested URI under the caller’s authorization policy instead of treating it as an executable tool name.
Incorrect Answers
A:Sampling settings influence generation, not resource addressing. They cannot identify which document the server should return during a resource-read request.
C:A document’s identity matters for provenance and consistency. Ignoring the published URI can return unrelated data and breaks traceability across repeated reads.
D:A readable resource is not automatically a tool with the same title. Tool invocation and resource retrieval use different MCP contracts and must not be conflated.
Question 396
A tool-call system must restrict which commands an assistant can perform. What should be configured first?
- Adjust a subagent rather than adding a generic web-search MCP tool.
- Use a prompt or Skill to organize the tool's returned data.
- Adopt a tool for fetching and a reusable prompt or Skill for rubric application.
- Restrict actual tool permissions rather than relying only on Skill text.
Explanation
Correct Answer
D:Tool availability and authorization define what can execute; a procedural document cannot enforce a security boundary.
Incorrect Answers
A:A subagent creates an isolated reasoning role, whereas an MCP tool supplies an external capability; when the goal is executable permission enforcement, optimizing specialist agent versus external tool misses that operational boundary.
B:Tool interfaces retrieve facts; reusable instructions define how those facts should be presented; for executable permission enforcement, this instead manages multi-criterion integration; the requested decision remains unresolved.
C:Retrieval is an executable integration, while evaluation criteria are instructions; separating them improves testability; testing executable permission enforcement would still fail after improving capability versus procedure separation.
Question 397
A reusable Claude Code Skill has a short SKILL.md file but dozens of detailed examples. Loading all examples into every session would waste context. How should it organize the supporting material?
- Delete the examples and rely on an unwritten assumption that the procedure is obvious.
- Paste all example files into every system prompt, including unrelated tasks.
- Keep concise activation instructions in SKILL.md and place detailed references in files that can be opened when relevant.
- Convert the examples into full-access shell tools so the assistant never needs to read them.
Explanation
Correct Answer
C:A compact entrypoint helps the assistant decide when the Skill applies without flooding its active context. Task-specific reference material can be loaded as needed while remaining versioned with the Skill package.
Incorrect Answers
A:Removing supporting material loses the edge cases that make the procedure reliable. A better package preserves the examples while loading only the relevant ones.
B:Unconditional prompt expansion consumes tokens and buries relevant instructions. The extra detail should be retrieved only for tasks that require it.
D:Reference examples are data and guidance, not an authorization basis for executable operations. A shell integration would add unnecessary privileges without fixing context cost.
Question 398
A user asks an agent to access a company's CRM through a connector already offered as a supported MCP service. What should integration evaluate?
- Organize the procedure as an Agent Skill.
- Establish a narrow client-side custom tool for the application.
- Reuse the service after checking its permissions, authentication, and tool contracts.
- Adopt an appropriate built-in tool when its features and permissions meet the task.
Explanation
Correct Answer
C:Existing MCP connectivity saves implementation work only when its security and capabilities fit the application.
Incorrect Answers
A:Skills supply reusable instructions and assets, whereas tools represent callable capabilities with executable behavior; for evaluating existing MCP integration, this instead manages procedural customization; the requested decision remains unresolved.
B:A direct tool definition fits an app-specific operation without the deployment complexity of a reusable server protocol; when the goal is evaluating existing MCP integration, optimizing one-app custom tool misses that operational boundary.
D:Built-ins reduce custom integration burden, but their scope must still be controlled; it changes built-in file tool fit; it does not prove evaluating existing MCP integration in this case.
Question 399
A task requires image analysis, web research, and updating a document. How should the developer choose customization mechanisms?
- Apply a tool for fetching and a reusable prompt or Skill for rubric application.
- Set a subagent rather than adding a generic web-search MCP tool.
- Compose supported built-in and custom tools for actions with instructions for orchestration.
- Build the operation behind a secure MCP server or equivalent controlled service.
- Choose the built-in when it satisfies functionality without extra trust boundaries.
Explanation
Correct Answer
C:No single Skill or MCP primitive replaces a complete agent design; each component should match the capability it provides.
Incorrect Answers
A:Retrieval is an executable integration, while evaluation criteria are instructions; separating them improves testability; it changes capability versus procedure separation; it does not prove mixed capability composition in this case.
B:A subagent creates an isolated reasoning role, whereas an MCP tool supplies an external capability; the consequence is improved specialist agent versus external tool, not verified mixed capability composition.
D:A server boundary can own credentials and permissions for all clients instead of copying privileged code into each prompt; even if centralized tool service control succeeds, mixed capability composition still needs separate verification.
E:New server deployments introduce authentication, latency, and maintenance overhead that may not add value; for mixed capability composition, this instead manages avoid redundant custom integration; the requested decision remains unresolved.
Question 400
A team conflates 'agent', 'tool', and 'Skill' as interchangeable components. What architectural distinction matters?
- Route every assistant component through an MCP server to merge agents, tools, and Skills into one abstraction.
- Save the instructions and examples in a Skill or repository guidance.
- Use agents for choosing actions, tools for executing capabilities, and Skills for reusable procedures.
- Prepare a subagent rather than adding a generic web-search MCP tool.
Explanation
Correct Answer
C:Separating planning, execution, and instruction assets reduces confused responsibility and unnecessary complexity.
Incorrect Answers
A:An MCP server can expose executable capabilities, but it is not the agent that chooses actions and does not transform a reusable instructional Skill into a tool. Hosting cannot erase architectural role distinctions.
B:Stable instructions can be invoked consistently without implementing a server-side action endpoint; the consequence is improved repeatable editing instructions, not verified autonomy capability instruction distinction.
D:A subagent creates an isolated reasoning role, whereas an MCP tool supplies an external capability; the effect concerns specialist agent versus external tool; the success condition is autonomy capability instruction distinction.