# Skills vs MCP: what each does and when to use both

> The skills vs MCP debate mixes up two layers. A skill is a written procedure an agent loads when a task needs it; an MCP server is a connection to tools and data outside the agent. Most real work needs both, and the harder question is how a team keeps the same skill in every tool.

Written 2026-11-02 · Agent fundamentals

Web version: https://getspace.sh/articles/skills-vs-mcp

## The short answer

Agent skills and MCP servers solve different problems. A skill is a folder with a SKILL.md file: written instructions, plus optional scripts, references and templates, that tell an agent how to do one kind of work. An MCP server is a program that an AI application connects to over the Model Context Protocol, and it offers that application tools to call, resources to read and prompts to use.

Anthropic puts the difference in one line: MCP connects Claude to data, and skills teach Claude what to do with that data. If you are explaining how to use a tool or follow a procedure, that is a skill. If the agent cannot reach the database or the file in the first place, that is MCP.

So the useful question is rarely skills or MCP. It is which part of the job is a procedure, which part needs a connection, and how each one reaches the people and tools that need it.

Sources: [Anthropic, Skills explained: how Skills compares to prompts, Projects, MCP, and subagents](https://claude.com/resources/articles/skills-explained); [Agent Skills, Specification](https://agentskills.io/specification); [Model Context Protocol, Architecture overview](https://modelcontextprotocol.io/docs/learn/architecture)

## Skills and MCP side by side

This table compares the two on the points that decide a design, from the Agent Skills specification, the MCP specification and Anthropic's documentation, as read on 2 November 2026.

| Question | Agent skill | MCP server |
| --- | --- | --- |
| What it is | A folder with a SKILL.md file (YAML front matter with a name and a description, then Markdown instructions) and optional scripts/, references/ and assets/ folders | A program that offers tools, resources and prompts to an AI application over JSON-RPC, running locally over stdio or remotely over Streamable HTTP |
| What it gives the agent | Procedural knowledge: the steps, the format and the checks for one kind of work | Access: actions it can take and data it can read outside its own context |
| Who decides to use it | The agent, by matching the request to the skill's description, or the person, by naming it (in Claude Code, /skill-name) | The model calls tools; prompts are user-controlled in the specification, meant to be picked by the person, for example as slash commands |
| Context cost before use | About 100 tokens per skill for the name and description; the full SKILL.md loads only when the skill is used, and other files only when the instructions call for them | The server's tools are offered to the application as available capabilities; how much of that sits in the model's context depends on the application, since MCP does not dictate how applications manage context |
| Where its code runs | Bundled scripts run in the agent's own environment, so they need a shell or code execution there | On the server, which keeps its own credentials; a remote server authenticates its clients, and MCP recommends OAuth for that |
| How an edit reaches users | Every copy of the folder has to be updated in each place a tool reads it | Change it once on the server; a server can notify connected clients that its list of tools or prompts changed |

The last row is where most team setups break, and it gets its own section below.

Sources: [Agent Skills, Specification](https://agentskills.io/specification); [Model Context Protocol, Architecture overview](https://modelcontextprotocol.io/docs/learn/architecture); [Model Context Protocol specification, Prompts](https://modelcontextprotocol.io/specification/2025-06-18/server/prompts); [Anthropic, Extend Claude with skills](https://code.claude.com/docs/en/skills)

## When a skill is the right answer

Write a skill when the agent already has what it needs and lacks only the method.

- You keep pasting the same instructions, checklist or multi-step procedure into chat. Anthropic's Claude Code documentation names this as the signal to create a skill, along with a section of CLAUDE.md that has grown into a procedure rather than a fact.
- The output has a house format: a client report with fixed sections, a code review summary, a release note. The template and the checklist go in the skill folder, so the format travels with the steps.
- You need the agent to use a tool it already has in a particular way. Anthropic's example is a rule such as "when querying our database, always filter by date range first": the connection already exists, and the rule is the skill.
- The reference material is long but rarely needed. A skill's body loads only when it is used, so a long procedure costs almost nothing until then, unlike an instructions file that loads in every session.

Sources: [Anthropic, Extend Claude with skills](https://code.claude.com/docs/en/skills); [Anthropic, Skills explained: how Skills compares to prompts, Projects, MCP, and subagents](https://claude.com/resources/articles/skills-explained)

## When you need an MCP server

Reach for MCP when the missing piece is access, not method.

- The data lives outside the agent's machine: a ticket tracker, a CRM, a database, a document store. Instructions cannot fetch it; a connection can.
- The action needs credentials that should not be copied onto every laptop. A remote MCP server keeps them on the server and authenticates each client, and the protocol recommends OAuth to obtain tokens.
- Several people or several AI applications need the same live source. A remote server using Streamable HTTP typically serves many clients, while a local stdio server typically serves the one application that started it.
- The work happens where there is no shell. A skill's scripts need somewhere to run, while an application that supports MCP can call a connected server's tools without one.

Sources: [Model Context Protocol, Architecture overview](https://modelcontextprotocol.io/docs/learn/architecture); [Agent Skills, Specification](https://agentskills.io/specification)

## Using both: the skill says how, the server gives access

Most useful setups combine them, and Anthropic recommends exactly that: MCP for connectivity, skills for procedural knowledge. A weekly client report is a typical case. An MCP server gives the agent read access to the CRM and the analytics account. A skill holds the report's sections, the order of the checks, the rule to cite the source of every figure, and the template. Without the server the skill has nothing to read; without the skill each person's agent reads the same data and writes a different report.

The pairing also helps with the common complaint that a server with dozens of tools leaves the agent guessing. A skill can name the two or three tools the job needs and the order to call them in. In Claude Code, a skill's allowed-tools field can also let Claude use the listed tools without asking permission during the turn that invokes the skill.

Some developers go further and replace a thin MCP server with a skill that documents a command-line tool, since a coding agent already has a shell. That can work for one developer on one machine. It moves the credentials onto each machine and does nothing for a colleague working in a chat app, which is why the choice depends on who needs the job done, not on which format is newer.

Sources: [Anthropic, Skills explained: how Skills compares to prompts, Projects, MCP, and subagents](https://claude.com/resources/articles/skills-explained); [Anthropic, Extend Claude with skills](https://code.claude.com/docs/en/skills); [Agent Skills, Specification](https://agentskills.io/specification)

## The part the debate skips: one skill in every tool

Skills are a shared format, but each tool reads them from its own places: Claude Code from .claude/skills, Codex from .agents/skills, ChatGPT from skills in its desktop app or bundled in plugins. A team using three tools keeps three copies in step, or commits one copy to a repository that only its coding agent users ever open.

MCP offers a second route. The protocol lets a server offer prompts, and Claude Code lists a connected server's prompts as commands, so one server can hand every client that supports prompts the current text of a playbook. Two limits apply. Prompts are user-controlled in the specification, so the person picks the playbook rather than the agent applying it on its own. And a local skill that quietly fetches its real instructions from a server is not allowed for software listed in Anthropic's directories: its Software Directory Policy says instructional software must not direct Claude to dynamically pull behavioral instructions from external sources for Claude to execute.

Sources: [Anthropic, Extend Claude with skills](https://code.claude.com/docs/en/skills); [OpenAI, Build skills](https://learn.chatgpt.com/docs/build-skills); [Model Context Protocol specification, Prompts](https://modelcontextprotocol.io/specification/2025-06-18/server/prompts); [Anthropic Software Directory Policy](https://support.claude.com/en/articles/13145358-anthropic-software-directory-policy)

## Where Space fits

Space is the workspace this article uses as an example of combining the two. It keeps a team's skills in one Space and serves them, with the team's documents and memory, to the AI tools its people connect over MCP. Agents see the Space's skills when they connect. When a request matches one, Space instructs the agent to offer it in one sentence and to apply it only once the person agrees, so the person stays in control of which playbook runs.

A person can also pick a skill as an MCP prompt in clients that list prompts, ask for it by name in any client, or have their agent install it into its own skills folder; an installed copy is current only after it is reinstalled. Only the Space's owner can change a skill, so one person's agent cannot rewrite a playbook for everyone.

If all your skills belong next to the code and everyone uses the same coding agent, a committed .agents/skills or .claude/skills folder is simpler and you do not need Space. Space is for the playbooks people produce in several tools. Companies start with a pilot on one playbook.

Sources: [Space, Agent connections](https://getspace.sh/docs/connect); [Model Context Protocol specification, Prompts](https://modelcontextprotocol.io/specification/2025-06-18/server/prompts)

## A two minute decision checklist

Answer these in order before building anything.

- Can the agent already reach everything the job needs? If yes, write a skill. If not, add an MCP server for the missing access first.
- Is the problem that results differ between people or tools? That is a procedure problem: a skill, with the template and the checks as files.
- Does the job need credentials or live data shared by several people? Put that behind one remote MCP server, not in scripts on each laptop.
- Do the people doing this job use more than one AI tool? Then decide how the skill reaches each tool before writing it: committed folders, each vendor's channel, or one server.
- After any edit, check which tools picked it up. A skill that someone's tool cannot find is not yet a team standard.

Sources: [Agent Skills, Specification](https://agentskills.io/specification); [Model Context Protocol, Architecture overview](https://modelcontextprotocol.io/docs/learn/architecture)

## Further reading

- [Agent skills for teams: one playbook in Claude, ChatGPT and Codex](https://getspace.sh/articles/agent-skills-for-teams)
- [Codex skills: how to write, install and share them](https://getspace.sh/articles/codex-skills)
- [AGENTS.md vs CLAUDE.md: share one file across agents](https://getspace.sh/articles/agents-md-vs-claude-md)
- [MCP memory server: what it is and how to evaluate one](https://getspace.sh/articles/mcp-memory-server)
- [Agent connections in Space](https://getspace.sh/docs/connect)
- [Agent Skills specification](https://agentskills.io/specification)
- [Model Context Protocol architecture](https://modelcontextprotocol.io/docs/learn/architecture)

## From the team building Space

Space is the workspace this article uses as an example: a team's playbooks, documents, tasks and memory, served to AI tools through the Model Context Protocol. Claude Code, Codex, Hermes, Cursor, Claude, ChatGPT, Gemini and Cline have each been tested with Space. Space is open: create your account at app.getspace.sh and connect your agents from its Agents page.

[Agent connections in Space](https://getspace.sh/docs/connect)