Skills and MCP get compared as if you had to pick one, but they solve different problems. An MCP server connects an agent to a system it can't otherwise reach: a database, a ticket tracker, a phone line. A skill is a folder of instructions, and sometimes scripts, that teaches the agent how to do a particular job. MCP adds reach and a skill adds know-how. Anthropic puts it in one line: "MCP connects Claude to data; Skills teach Claude what to do with that data."

We build DialMCP, a remote MCP server that places real phone calls, so we deal with both halves every day. The server can enforce rules for every user, like calling hours, AI disclosure and an opt-out list. What it can't know is how you want calls run: whether to check with you before dialing, say, or which fallback times are fine. A skill covers that part. This guide explains what each one is, where they overlap, what each costs in context, and where each client looks for skills. It ends with a skill we wrote that drives an MCP server.

Skills vs MCP: the short answer

An open plastic toolbox under blue light, holding a row of precision screwdrivers, a bit set and a pair of pliers
An MCP server hands the agent the tools; a skill is the know-how for using them. Photo by Shixart1985, CC BY 2.0, via Wikimedia Commons (resized).
SkillMCP server
What it isA folder with a SKILL.md file, plus optional scripts and reference filesA program that speaks the Model Context Protocol, run locally or hosted
What it addsProcedure: steps, conventions, checks, templatesCapability: tools, resources and prompts backed by a real system
Where it runsInside the agent's own environment, with whatever access the agent already hasIn the server process, on your machine or someone else's infrastructure
Identity and authNone of its ownIts own credentials; many remote servers, DialMCP included, sign you in with OAuth, and you can revoke the token
Idle context costName and description, about 100 tokensTool definitions, unless the client defers them (Claude Code does by default)
Can it enforce a rule?Not by itself. It's guidance the model follows (in Claude Code, a skill can register hooks, and those can block actions)Yes. The server can refuse a request
PortabilityDozens of clients read the Agent Skills formatAny MCP client
Who writes itAnyone who can write a clear Markdown docA developer

The row that matters most is the one about enforcing rules. A skill can tell the model "never call before 9am," and the model will usually comply. An MCP server can simply refuse the call. Anything that has to hold every time belongs on the server side.

What a Claude skill is

A skill is a directory with a SKILL.md file in it. The file opens with YAML frontmatter that needs two fields: a name (up to 64 lowercase letters, digits and hyphens, matching the folder name) and a description (up to 1,024 characters) saying what the skill does and when to use it. Markdown instructions follow. The folder can also hold scripts/, references/ and assets/. Anthropic introduced Agent Skills on October 16, 2025 and published the format as an open standard on December 18, 2025. The spec now lives at agentskills.io, with code under Apache 2.0 and docs under CC BY 4.0.

Skills stay cheap because of progressive disclosure, which happens in three stages:

  1. Discovery. At startup the agent loads only each skill's name and description. Anthropic puts that at about 100 tokens per skill.
  2. Activation. When a request matches a description, the agent reads the full SKILL.md into context. The spec suggests keeping it under 5,000 tokens and 500 lines.
  3. Execution. The agent follows the instructions, and opens bundled files or runs bundled scripts only when it needs them.

So the description does all the work of triggering. If it's vague, the skill never loads. If it's too broad, it loads when it shouldn't.

Where skills run in Claude

The same folder behaves a little differently on each Claude surface, and the differences matter for anything that reaches outside the sandbox.

  • Claude apps. You zip the folder and upload it under Customize > Skills. Code execution has to be on. Team and Enterprise owners can provision skills for the whole organization. Network access depends on user and admin settings.
  • Claude Code. Skills live in ~/.claude/skills/<name>/ for you or .claude/skills/<name>/ for a repository. Claude picks one up when it's relevant, or you type /skill-name. Custom slash commands have been merged into skills. Claude Code also accepts extra frontmatter, such as allowed-tools, paths and context: fork. Stick to the spec's fields if you also want to upload the skill to the Claude apps or the API, because unknown fields make the upload fail.
  • Claude API. Skills run with the code execution tool, up to 20 per request, and the Skills API is out of beta. The container has no network access and can't install packages at runtime. A skill there can't call your issue tracker, however good its script is.

Anthropic's prebuilt document skills (pptx, xlsx, docx, pdf) work in the apps and the API, but not in Claude Code.

What an MCP server is

The Model Context Protocol is an open standard for connecting AI applications to outside systems. A server exposes three kinds of things: tools the model decides to call, resources the application reads for context, and prompts, which are templates the user picks. A client inside the host app (Claude, ChatGPT, Cursor, Codex, VS Code) connects to the server, lists what it offers, and hands the tool definitions to the model. Our guide to MCP tools, prompts and resources covers who controls each one. The current spec revision is 2026-07-28, which made the protocol stateless.

Servers run locally over stdio or remotely over Streamable HTTP. Many remote servers sign you in with OAuth, so they act with a token that belongs to you and that you can revoke. Skills have no equivalent. DialMCP, for example, is a remote server: you add https://mcp.dialmcp.com/mcp, verify your phone number, and from then on every call goes out from that number, under your account's limits.

Where skills and MCP overlap

Most of the confusion comes from three places where the two look alike.

MCP prompts vs skills

An MCP prompt is a reusable template a server offers. Claude Code shows it as a slash command, /mcp__servername__promptname. A skill packages instructions too. The difference is who triggers it and what it can cover. A prompt is picked by the user and comes from one server, so it's written around that server's tools and resources. A skill is picked by the model from its description, and one skill can span several servers, a shell and some local files.

Server instructions vs skills

A server can also send an instructions string, which is optional guidance for the model on how to use it. Claude Code's docs say these "help Claude understand when to search for your tools, similar to how skills work," and cut them off at 4,096 characters. Anthropic's rule of thumb draws the line well: MCP instructions "cover how to use the server and its tools correctly," and skill instructions "cover how to use them for a given process or in a multiserver workflow." A server author writes the first kind once, for everyone. You write the second kind for yourself or your team. Keep them from contradicting each other. If the server asks for JSON and your skill asks for Markdown tables, Anthropic notes, Claude has to guess.

Can a skill replace an MCP server?

Sometimes. A skill can bundle a script that calls an HTTP API, or tell the agent which CLI to run. In Claude Code, which has a shell and the same network access as any program on your machine, that's often enough, and a CLI costs no context until it runs. On the API the same skill can't reach the network at all. A script also inherits whatever credentials sit in the environment. It can't give each user their own OAuth sign-in to the remote system, and it can't impose rules that the system's operator controls. For a hosted service shared by many people, an MCP server is the better fit. Anthropic's answer to "do skills replace MCP?" is a flat no, and on that point we agree.

Context cost: what each one loads

Context is where skills earned their reputation. An idle skill costs only its metadata. MCP clients used to load every tool definition on every turn, and Anthropic's own comparison table still says MCP "definitions loaded upfront." Claude Code changed that: tool search is on by default, so "only tool names and server instructions load at session start," and full definitions are fetched when needed. With older models, or with ENABLE_TOOL_SEARCH=false, everything loads upfront again. Not every client defers tools, so short tool lists and tight descriptions still pay off.

Tool results are the other cost. Claude Code warns when an MCP tool returns more than 10,000 tokens and caps output at 25,000 by default. A skill's script can filter data before the model sees it. An MCP tool returns whatever the server sends, so a well-built server keeps results compact. DialMCP's get_call, for instance, returns a short resolution object next to the transcript, so the agent can answer "did it work?" without reading the whole call.

Where each client looks for skills

The format is shared, but the folder isn't. If you want one skill to work in several agents, put it where each of them will find it. As of November 11, 2026, their own docs say:

ClientProject skillsPersonal skills
Claude Code.claude/skills/~/.claude/skills/
OpenAI Codex.agents/skills/ (from the working directory up to the repo root)~/.agents/skills/
Cursor.agents/skills/, .cursor/skills/, plus .claude/skills/ and .codex/skills/The same names under ~/
Gemini CLI.gemini/skills/ or .agents/skills/~/.gemini/skills/ or ~/.agents/skills/
GitHub Copilot (VS Code).github/skills/~/.copilot/skills/

These are the main locations, not every one each client supports. Claude Code's docs don't mention .agents/skills/, and Codex's and Gemini CLI's don't mention .claude/skills/. A repository that wants both needs the skill in both places, or a symlink. MCP servers have the same split, since each client keeps its own config file. Our guide to mcp.json files maps those.

When to use a skill, an MCP server, or both

  • Use a skill when the agent already has the access it needs and what's missing is procedure: your release checklist, your brand rules, how your team writes migrations, which spreadsheet formulas to use.
  • Use an MCP server when the agent needs to reach something behind a login, act as a specific user, or work through a system with its own rules. A CRM, a calendar, a payments API and a phone line all qualify.
  • Use both when you want the agent to follow your process inside someone else's system, which is the usual case. The server provides the tools. The skill says when to call them, in what order, and what to check afterwards. One skill can drive several servers, and one server can back many skills.

If you're short on time, start with the skill. It's a text file you can read and fix in minutes. Add the server once you need real access, per-user identity, or rules that have to hold whatever the model decides.

A worked example: a skill that drives an MCP server

Here's a skill we wrote for DialMCP. The server already handles the parts that can't bend. It only dials US and Canadian numbers between 8am and 9pm in the destination's local time. Its voice agent says it's an AI calling on your behalf. Numbers that opt out are blocked for good, and rate limits apply per account. None of that depends on what the model was told.

The skill adds the parts that depend on you: confirming before dialing, writing a good objective, polling correctly and reading the result honestly. In Claude Code it lives at .claude/skills/phone-errands/SKILL.md:

---
name: phone-errands
description: Place a phone call for the user with DialMCP to book, reschedule, cancel or ask about something (a restaurant, clinic, salon, shop or office). Use when the user asks you to call a business, or when finishing a task needs a phone call.
allowed-tools: mcp__dialmcp__get_call mcp__dialmcp__list_calls
---

# Phone errands

1. Before dialing, confirm the number, the goal and the acceptable fallbacks
   with the user in one short message. Never call a number you guessed.
2. Write the objective as instructions to a capable assistant: the goal, every
   specific (names, dates, party size), and what to accept if the first choice
   is unavailable. Put private details the callee may need, such as a date of
   birth, in `context`, not in `objective`.
3. Call `place_call`. Offer the user the `listen_url` from the response.
4. Follow up with `get_call` until the status is final. Use `wait_seconds`
   only if your tool timeout is longer than the wait; otherwise poll about
   every 20 seconds.
5. Read `resolution` first. Report `outcome`, `commitments` and `follow_ups`.
   Treat `completed` as "the call ended", not "it worked".
6. If the result is `opted_out` or `declined_recording`, or
   `callee_requested_no_further_calls` is true, do not call again.
   If `place_call` returns `outside_calling_hours` or `rate_limited`, tell
   the user when to retry instead of retrying.
7. For confirmation codes and prices, quote the transcript, not the summary.

It passes the spec's reference validator (skills-ref 0.1.1). The whole file is about 225 words, but at discovery the agent only sees the name and the 43-word description. Each step maps to a line in DialMCP's tool reference. completed only means the call ended normally, so the skill sends the agent to resolution.outcome. The listen_url lets you hear the call live and stop it, so the skill makes sure you're offered it. Rejections carry machine-readable timing: rate_limited includes a reset_at time, and outside_calling_hours includes the destination's local hour and time zone. The skill passes those on instead of looping.

The allowed-tools line is a Claude Code feature, and the spec still marks it experimental. It pre-approves the two read-only tools for the turn that invokes the skill, so polling doesn't prompt you every 20 seconds, while place_call still asks. The names assume you added the server as dialmcp. Claude Code names MCP tools mcp__<server>__<tool>, so adjust them if you picked another name.

Now look at what the skill leaves out. There's no "don't call at night" and no "say you're an AI," because those would only be requests to the model. The server enforces both for every client and every prompt, and a skill on top can't weaken them. That's the split we'd suggest for any MCP server that acts in the real world. Put the guarantees in the server and the preferences in a skill.

Plugins: shipping both together

In Claude Code you don't have to hand out the two pieces separately. A plugin is "a directory of skills, agents, hooks, MCP servers, or other components that Claude Code installs and loads as one unit," listed in a marketplace, which is just a repository with a .claude-plugin/marketplace.json file. A team can ship "connect to our ticketing server, plus the skill for triaging tickets" as one install. The MCP project does this itself: its mcp-server-dev plugin packages skills for building MCP servers. Keep in mind that an enabled plugin's skill descriptions sit in context on every turn, and its MCP servers start with every session.

Security: both run with your access

Treat a skill from the internet like code from the internet. Anthropic's advice is to use skills "only from trusted sources" and to audit everything bundled, scripts included, because "a malicious Skill can direct Claude to call tools or run code in ways that don't match the Skill's stated purpose." In Claude Code, a skill checked into a repository can pre-approve tools for itself, even in a non-interactive claude -p run in a folder you've never trusted, so read its allowed-tools before you run Claude there.

MCP has its own risks: tool poisoning through descriptions, prompt injection through tool results, and over-broad tokens. Our MCP security guide covers them, with a checklist for server authors. Neither layer should be your only defense. Scope tokens narrowly, keep approval prompts on for actions that change things, and push hard limits into the server, where a persuasive prompt can't talk its way past them.

Setting up the server half in Claude? Start with how to add an MCP server to Claude or our Claude Code MCP guide.

Further reading

Try a remote MCP server that does real work. DialMCP lets Claude, ChatGPT, Codex, Cursor or VS Code place real phone calls from your own verified number and hand back a transcript and a structured outcome. Add https://mcp.dialmcp.com/mcp as a connector and sign in. US and Canada, free during launch.

Connect DialMCP to your client

FAQ

What is the difference between Claude Skills and MCP?

A skill is a folder with a SKILL.md file that teaches Claude a procedure: steps, conventions and optional scripts, loaded only when a request matches its description. An MCP server is a program that connects Claude to an outside system, such as a database, a calendar or a phone line, and exposes tools Claude can call. Skills add know-how; MCP adds reach.

Do Claude Skills replace MCP?

No. A skill has no identity, credentials or network access of its own, so it can't sign each user in with OAuth or enforce rules the way a server can. In Claude Code a skill can script an API or CLI through the shell, which sometimes removes the need for a server, but on the Claude API skills run in a container with no network access.

Can a skill call MCP tools?

Yes. A skill's instructions can tell Claude when and how to call tools from any connected MCP server, and one skill can coordinate several servers. In Claude Code, MCP tools are named mcp__<server>__<tool>, and a skill's allowed-tools field can pre-approve specific ones for the turn that invokes it.

Are Agent Skills only for Claude?

No. Anthropic published Agent Skills as an open standard on December 18, 2025, and the spec lives at agentskills.io. OpenAI Codex, Cursor, Gemini CLI and GitHub Copilot read SKILL.md files, though each scans its own folders, such as .agents/skills, .cursor/skills or .github/skills.

Are MCP prompts the same as skills?

No. An MCP prompt is a template a server offers, which the user picks, often as a slash command, and it's written around that server's tools and resources. A skill is chosen by the model from its description, lives in the agent's own environment, and can span several servers, a shell and local files.

Do skills use less context than MCP servers?

An idle skill costs only its name and description, about 100 tokens. MCP clients have traditionally loaded every tool definition upfront, but Claude Code's tool search, on by default, loads only tool names and server instructions at session start and fetches full definitions when needed.