What you will be able to do
- Place a capability as a built-in tool, custom tool, Skill or MCP server by asking where its code runs, who maintains it and how Claude discovers it
- Tell when the tools Claude Code already has make an extra MCP server unnecessary
- Explain why one MCP server suits an integration that several Claude clients share
- Explain why a Skill suits a procedure used only now and then, and why CLAUDE.md, a custom tool or MCP does not
- Defend a design that pairs mechanisms, such as an MCP connection with a Skill that teaches how to use it
Key concept
Where the capability lives — Each way of extending Claude puts its code in a different place: on Anthropic's infrastructure, in your application, in a Skill folder Claude reads, or in a separate MCP server that any compatible client can connect to. Where the code lives decides who maintains it and how Claude finds it, so it is the first thing to settle when choosing a mechanism.
1.Three questions that place any capability
There are several ways to give Claude a new ability, and they are not interchangeable. You can enable a tool Anthropic already provides. You can define your own tool. You can package instructions and scripts as a Skill. Or you can put a system behind an MCP server. Choose the wrong one and you pay for it later: a team maintains the same integration three times, or a procedure fills the context window in every session when it is needed twice a month.
Three questions settle most of these choices. Where must the capability live? On Anthropic's infrastructure, inside your application, in files next to the project, or in a separate service. Who maintains it? Anthropic, your application team, whoever owns the Skill folder, or whoever runs the server. How does Claude discover and invoke it? From a tool definition sent with the request, from a Skill description loaded at startup, or from the tools a connected MCP server exposes. Tool use itself splits along the first question. Client tools run in your application, and server tools run on Anthropic's side and return results directly.
| Mechanism | Where it lives | Who maintains it | How Claude discovers and invokes it |
|---|---|---|---|
| Built-in tool (e.g. web_search, bash, Grep, Edit) | Anthropic's infrastructure (server tools), or your application or Claude Code (client tools) | Anthropic publishes it; you enable it | Already in the tool list; Claude calls it when the request fits |
| Custom tool | Your application, which runs each call | You: schema plus handler, in each application that defines it | Definition sent in the request's tools array; Claude returns a tool_use block |
| Skill | A folder with SKILL.md, reference files and scripts | Whoever owns the folder (personal, project, enterprise, plugin) | Name and description load at startup; the body loads when the description matches the task |
| MCP server | A separate local or remote server | The server's owner, once, for every client that connects | Its tools become available to any client that registers the server |
Two more mechanisms come up beside these four, and each is defined by a single property. CLAUDE.md holds rules that load into every session. A hook runs on a lifecycle event whether or not Claude decides to act, which makes it the tool for deterministic enforcement. Both are covered under Claude Code extension features. Here they matter only as the wrong answer when the need is an occasional procedure or access to an outside system.
Checkpoint 1 of 8· Match them up
Match each way of extending Claude to where it lives and how Claude finds and calls it
Tap a term, then the definition that fits it.
The three questions (where it lives, who maintains it, how Claude finds it) give each mechanism a different answer. Server tools run on Anthropic's side and custom tools run in your application. A Skill loads in stages, starting from its description. An MCP server is maintained once and serves every client that connects to it.
“It then returns a structured call that your application runs (client tools) or that Anthropic runs (server tools).”Source: platform.claude.com
2.Check the built-in tools before building anything
Built-in tools need no code from you, so they are the cheapest choice whenever they already cover the job. In the Messages API they come in two kinds. Server tools such as web search, web fetch, code execution and tool search run on Anthropic's infrastructure with no handler code in your application. Anthropic-schema client tools such as bash and text_editor are different: Anthropic defines the schema and trains Claude on it, but your application still runs each call.
Claude Code has its own large set of built-in tools, and they reach well past a shell. Each one has a narrow job, and the job description is what settles a selection question. Glob matches file paths against a pattern. Grep searches the contents of files. Edit changes specific files in place. Each tool also carries its own permission setting: Edit and Bash ask for permission, while Read and Grep do not. Permission to touch files belongs to the tool. Wrapping steps in a Skill does not grant it.
| Tool | What it does | Permission required |
|---|---|---|
| Glob | Finds files based on pattern matching | No |
| Grep | Searches for patterns in file contents | No |
| Read | Reads the contents of files | No |
| Edit | Makes targeted edits to specific files | Yes |
| Bash | Executes shell commands in your environment | Yes |
A refactor inside the working tree is the clearest case of not adding anything. Grep finds the call sites and Edit changes them. A filesystem MCP server would duplicate those tools and become one more component to configure and keep running. A custom search tool would solve a problem that does not exist. Built-in tools fall short when the data lives somewhere Claude cannot reach, and the next two mechanisms exist for that situation.
Checkpoint 2 of 8· Check yourself
A Messages API application enables two built-in tools: the web_search server tool and the Anthropic-schema bash tool. Which statement about how their calls get executed is correct?
Server tools such as web_search run on Anthropic's infrastructure. Bash has a schema that Anthropic defines, but it is still a client tool, so your application runs each call.
“Client tools (including user-defined tools and tools with Anthropic-defined schemas, such as bash and text_editor) run in your application.”Source: platform.claude.com
Checkpoint 3 of 8· Exam question
A developer uses Claude Code to refactor a service in a local repository. Claude needs to find every call site of a function and then edit those files. The developer asks whether to add a filesystem MCP server for this. What is the best justification for the decision?
Correct answer: C — Skip the extra server, because the built-in Grep and Edit tools in Claude Code already search file contents and change files in the working tree.
- A. Incorrect. Claude Code's built-in file access does not stop at Bash. It also includes dedicated tools for reading, searching and editing files. Finding call sites and editing those files is already covered, so a filesystem MCP server would add a process to run without adding a capability.
- B. Incorrect. Glob matches file paths, but Grep searches the text inside files, so it can locate every occurrence of a function in source code. A custom search tool would duplicate something Claude Code already provides and maintains.
- C. Correct. Claude Code ships built-in tools for searching file contents (Grep) and modifying files (Edit), alongside Read. Locating call sites and editing those files already works in a local repository, and a filesystem MCP server would only duplicate that.
- D. Incorrect. Skills package instructions and supporting resources for Claude to follow. They do not grant file access or permissions. Reading and editing files comes from the built-in tools, so a Skill is the wrong mechanism for reaching the code.
3.Custom tools against MCP for an integration many clients share
A custom tool is the right size when one application owns the integration. You write the schema and the handler, Claude returns a tool_use block, and your code runs the operation and sends back a tool_result. The cost shows up when a second and third client need the same system. Each one carries its own copy of the schema, its own handler and its own permission checks, and those copies drift apart. How to write a good tool definition is covered under tool design.
MCP moves the integration out of the clients and into one server. That server holds the connection to the outside system and exposes its operations as tools. Every client that registers the server gets those tools, and the access logic, maintained in one place. In Claude Code you register a server with a single command. A Messages API application can reach a remote server through the MCP connector without writing an MCP client of its own. How servers are built and secured is covered under MCP server development.
# Basic syntax
claude mcp add --transport http <name> <url>
# Real example: Connect to Notion
claude mcp add --transport http notion https://mcp.notion.com/mcpConsider a ticketing system used by engineers in Claude Code, by a support team in Claude Desktop, and by an internal chat agent built on the Messages API. All three need to read and update tickets under the same permissions. One MCP server in front of the ticket system meets that requirement, with the permissions enforced in the server. The alternatives each break somewhere:
- Per-client custom tools mean three schemas and three handlers, which is the duplication the requirement rules out.
- A Skill holding API instructions and scripts cannot be the live connection on the API platform, because Skills there run in a sandbox with no network access.
- Built-in web fetch retrieves the content of webpages and PDFs. It is not a maintained integration with a shared permissions model, and every client would still need the vendor's endpoints and a token of its own.
Checkpoint 4 of 8· Check yourself
Three clients need to read and update records in an inventory system: engineers in Claude Code, staff in Claude Desktop, and an agent built on the Messages API. Which proposed design cannot work, as opposed to just being costly to maintain?
On the API platform, Skills run in a sandboxed container with no network access, so helper scripts in a Skill cannot hold a live connection to the inventory system. Per-client custom tools would work but duplicate the integration three times, and the MCP server is the intended design.
“Skills on the API run in a sandboxed container with no network access and no runtime package installation.”Source: platform.claude.com
Checkpoint 5 of 8· Exam question
A company's support platform is used from Claude Code by engineers, from Claude Desktop by the support team, and from an internal chat agent. All three should look up and update tickets using the same permissions model and one maintained integration. Which mechanism fits best?
Correct answer: A — Run the ticket system behind an MCP server and register it with Claude Code, Claude Desktop and the chat agent, with tools discovered on connection.
- A. Correct. MCP is the open standard for exposing an external system to different Claude hosts. One server holds the ticket logic and authorization, and Claude Code, Claude Desktop and the chat agent all use the same tools and permissions.
- B. Incorrect. Separate schemas and handlers in each client produce three implementations of the ticket operations and three permission checks that can drift apart. That contradicts the need for one maintained integration and a shared permissions model.
- C. Incorrect. A Skill supplies instructions and scripts to Claude but is not a shared, authenticated service. Installing it in each client leaves three copies to maintain, with no central place to enforce one permissions model for tickets.
- D. Incorrect. The web fetch tool retrieves content from URLs and is not a defined, authenticated interface for updating tickets. Distributing a token to each client also spreads credential handling across clients instead of one permissions model.
4.Skills for procedures that should load only when needed
A Skill packages knowledge, not a connection. It is a folder whose SKILL.md holds instructions, and it can hold reference files and scripts beside it. Claude finds a Skill through its YAML frontmatter. The name and description load at startup, at roughly 100 tokens per Skill, and Claude compares each request against the description. That is why the description has to say both what the Skill does and when to use it.
---
name: pdf-processing
description: Extract text and tables from PDF files, fill forms, merge documents. Use when working with PDF files or when the user mentions PDFs, forms, or document extraction.
---The rest of a Skill loads in stages. The body of SKILL.md enters context only when the Skill is triggered. A bundled reference file costs nothing until Claude reads it. A bundled script runs through bash, and only its output enters context, never its code. This makes a Skill cheap to keep installed even when it is large, as long as it is rarely needed.
A postmortem procedure is a good test case. CLAUDE.md loads every session automatically, so the template and checklist would sit in context through hundreds of sessions that never need them. A local MCP server would work, but MCP exists for external data and actions, and this case has none, so the server would be infrastructure with nothing to connect to. A custom tool defined in the Messages API does not exist inside Claude Code sessions at all. A Skill fits on every axis. It lives in a folder, it is maintained by whoever owns that folder, and Claude invokes it when a request matches its description.
Where the folder sits decides who gets the Skill. A project Skill at .claude/skills/<skill-name>/SKILL.md that is committed to the repository reaches everyone who works in that repository. An enterprise Skill in the managed settings directory reaches every user on machines where the organisation deploys it. On the Claude API, custom Skills uploaded through the Skills API are shared across the whole workspace.
Checkpoint 6 of 8· Match them up
A team installs a large Skill: a SKILL.md, a dozen reference files and a few scripts. For each part of the Skill, when does it enter Claude's context, and how much of it gets in?
Tap a term, then the definition that fits it.
Skills load in stages. Only the name and description are always present. The body loads when the Skill is triggered, reference files load when Claude reads them, and scripts add only their output. That is why a large but rarely used Skill is cheap to keep installed.
“Reference files load into context when read. Scripts run through bash, and only their output enters context.”Source: platform.claude.com
Checkpoint 7 of 8· Exam question
A platform team wants every Claude Code session to follow the company's incident postmortem procedure: a template, a checklist and a script that gathers log excerpts. The procedure is only relevant a few times a month, and no external service is involved. What is the best mechanism?
Correct answer: D — Create a Skill folder holding the template, checklist and script, which Claude loads when a postmortem request matches the skill's description.
- A. Incorrect. MCP exists to connect Claude to external systems and data, and none is involved here. A local server serving fixed text is a process to build and keep running, and it does not package the log-gathering script.
- B. Incorrect. CLAUDE.md is loaded when a session starts, so the procedure would take up context in sessions that never touch a postmortem, even though it is needed only a few times a month. It suits short, always-relevant rules.
- C. Incorrect. A tool defined in a Messages API request belongs to an application you build and run, not to Claude Code sessions. It also cannot bundle the template, checklist and script as one reusable unit.
- D. Correct. A Skill packages instructions, a template and a script in one folder. Claude reads only its short description up front and loads the full body when a task matches, which suits a rarely used procedure with no external service.
5.Combining mechanisms and defending the choice
The best answer is often two mechanisms, each doing the part it is suited to. MCP gives Claude access to a system, and a Skill teaches Claude how to use that access well. A database is a typical case. An MCP server provides the query tools, and a Skill documents the schema and the query patterns your team trusts. Neither one alone is enough: the server without the Skill leaves Claude guessing at table names, and the Skill without the server cannot run a query.
Scale changes the picture for tools. Once several MCP servers are connected, their tool definitions can take tens of thousands of tokens before any work starts. Claude's accuracy at picking the right tool also drops past roughly 30–50 available tools. Tool search addresses both problems: definitions marked defer_loading stay out of context until Claude searches for them. So "too many tools" calls for deferred loading, not for dropping MCP in favour of something else.
A defensible selection gives an answer to each of the three questions. For example: "The ticket system is external and three clients need it, so it lives in one MCP server its owning team maintains, and every client discovers the same tools when it connects." Or: "The postmortem steps involve no external system and are rarely used, so they live in a project Skill that Claude loads when the description matches." An argument that never names where the code runs, or who keeps it working, is a preference and not a justification.
A hook combined with MCP. The hook fires on the edit event without Claude deciding anything, and it triggers the Slack action through MCP. A Skill is instructions that Claude interprets, so its outcome can vary, which fails the "no exceptions" requirement.
Checkpoint 8 of 8· Check yourself
Your team has connected an MCP server that exposes query tools for the warehouse database. Claude can run queries, but it keeps guessing table names and writes joins the team doesn't trust. What change fixes this?
The server already gives Claude access. What Claude lacks is know-how, and a Skill supplies that. A Skill can't replace the server, because a Skill without the server can't run a query. Deferred loading fixes having too many tools, not missing schema knowledge.
“MCP provides the connection; a skill teaches Claude how to use it well”Source: code.claude.com
Sources
(7)
Every claim above is drawn from one of these pages, quoted as it was written on the date shown.
- 1.
“Client tools (including user-defined tools and tools with Anthropic-defined schemas, such as bash and text_editor) run in your application.”
↩︎ Three questions that place any capability“Anthropic publishes the schema and trains Claude on it. Your application still runs each call and returns the tool_result.”
↩︎ Check the built-in tools before building anything“For tools you define, you write the schema and your application runs each call.”
↩︎ Custom tools against MCP for an integration many clients share“Connect to remote MCP servers from the Messages API without a separate MCP client.”
↩︎ Custom tools against MCP for an integration many clients share“Retrieve the full content of specified webpages and PDF documents.”
↩︎ Custom tools against MCP for an integration many clients share“Tools differ primarily by where the code runs.”
↩︎ Key concept“It then returns a structured call that your application runs (client tools) or that Anthropic runs (server tools).”
↩︎ Checkpoint“Client tools (including user-defined tools and tools with Anthropic-defined schemas, such as bash and text_editor) run in your application.”
↩︎ Checkpoint - 2.https://code.claude.com/docs/en/features-overviewOfficial docs
“Fires on its event without Claude deciding”
↩︎ Three questions that place any capability“Protocol for connecting to external services”
↩︎ Custom tools against MCP for an integration many clients share“MCP provides the connection; a skill teaches Claude how to use it well”
↩︎ Combining mechanisms and defending the choice“MCP provides the connection; a skill teaches Claude how to use it well”
↩︎ Exam trap 4 - 3.https://code.claude.com/docs/en/tools-referenceOfficial docs
“Searches for patterns in file contents”
↩︎ Check the built-in tools before building anything“Finds files based on pattern matching”
↩︎ Check the built-in tools before building anything“Makes targeted edits to specific files”
↩︎ Exam trap 1 - 4.
“Like a USB-C port for AI applications, MCP provides a unified way to connect AI models to different data sources and tools.”
↩︎ Custom tools against MCP for an integration many clients share - 5.
“Scripts run through bash, and only their output enters context.”
↩︎ Skills for procedures that should load only when needed“Custom Skills are shared workspace-wide: all workspace members can access them.”
↩︎ Skills for procedures that should load only when needed“Skills on the API run in a sandboxed container with no network access and no runtime package installation.”
↩︎ Exam trap 2“The description is what Claude matches your request against when determining whether to trigger the Skill”
↩︎ Exam trap 3“Skills on the API run in a sandboxed container with no network access and no runtime package installation.”
↩︎ Checkpoint“until a Skill is triggered, only its name and description occupy context.”
↩︎ Prediction“Reference files load into context when read. Scripts run through bash, and only their output enters context.”
↩︎ Checkpoint - 6.https://code.claude.com/docs/en/skillsOfficial docs
“Sessions in this repository, but not cloud threads in a project. Commit it so your team gets it too”
↩︎ Skills for procedures that should load only when needed - 7.
“Instead of loading all tool definitions into the context window up front, Claude searches your tool catalog”
↩︎ Combining mechanisms and defending the choice