Skills vs MCP: When to Use a Claude Skill, an MCP Server, or Both

Use a skill when the agent needs to know how to do something, and an MCP server when it needs to reach something. A skill is a folder of instructions (a SKILL.md plus optional scripts and reference files) that the agent loads on demand. An MCP server is a running process that connects the agent to an external system, such as GitHub, a database, or your CRM, through tools it can call. Most real setups need both: the MCP server provides access, and the skill tells the agent how your team wants that access used.

This post compares the two on what they cost in context, where they run, how they are secured and shared, and then gives a decision guide with examples of using them together.

Skills and MCP side by side

	Agent Skill	MCP server
What it is	Instructions, scripts, and reference files in a folder	A process that exposes tools, resources, and prompts over JSON-RPC
What it gives the agent	Knowledge and procedure: conventions, runbooks, defaults, gotchas	Capability: read and write access to external systems
Format	SKILL.md with YAML frontmatter (agentskills.io spec)	Model Context Protocol specification (current revision 2026-07-28)
Where it runs	Inside the agent's context; bundled scripts run on the agent's machine with the user's permissions	As a local subprocess (stdio) or a remote service (Streamable HTTP)
What sits in context before use	name and description, about 100 tokens per skill	Tool names and descriptions; full JSON schemas unless the client defers them
Credentials	None of its own; it should never contain secrets	Usually holds upstream credentials (API tokens, OAuth grants)
Typical failure	Never triggers, or triggers for the wrong task	Too many tools, wrong tool picked, leaked tokens, destructive calls without approval
How teams share it	A git repo plus npx skills add, a plugin marketplace, or a registry	A shared remote server or an MCP gateway with one endpoint
Versioning	metadata.version in frontmatter, git tags	Package version of the server; pin it (npx -y pkg@1.2.3)

What each one costs in context

Context cost is where the two differ most in practice.

A skill loads progressively. At session start the agent sees only each skill's name and description. The full body (kept under about 5,000 tokens) loads only when the description matches the task, and files in references/ load only when the body says to open them. Ten installed skills cost roughly 1,000 tokens of metadata per session.

MCP tools are different. Classic MCP tool calling sends every available tool definition on every model turn. With ten servers and 150 tools, that can be tens of thousands of tokens per turn, repeated on every turn of an agent loop, and tool selection accuracy usually drops once more than 30 to 40 tools are visible at once.

Clients have started to close that gap. In Claude Code, MCP tool definitions are deferred by default, so only tool names and server instructions enter context until Claude uses a specific tool, according to the Claude Code cost documentation. Other hosts and custom agent loops may still send full schemas every turn. Gateways can also help: Bifrost's Code Mode replaces a large tool catalog with four meta-tools the model uses to discover and call tools on demand, and Bifrost's docs report up to 92.8% fewer input tokens in their benchmark at about 500 tools across 16 servers.

The same Claude Code page notes that CLI tools like gh, aws, gcloud, and sentry-cli remain more context-efficient than MCP servers because they add no per-tool listing. Sometimes the right answer is a skill that tells the agent which CLI command to run, and the decision guide below accounts for that.

When to use a skill

Pick a skill when the gap is knowledge the model does not have:

• Your repo's conventions: the migration tool, the test layout, the release steps.
• Internal API usage patterns, schemas, and naming rules.
• Runbooks and incident procedures that must run in a specific order.
• Review standards, writing standards, or a checklist you keep repeating in chats.
• A deterministic procedure you can ship as a tested script in scripts/.

A skill is the wrong tool when the agent needs live data or needs to change something in another system. Instructions cannot query your production database.

When to use an MCP server

Pick an MCP server when the gap is access:

• Reading or writing data in a system the agent cannot otherwise reach (tickets, CRM records, docs, a database).
• Actions with side effects: creating issues, posting messages, deploying.
• Per-user permissions, where each person should act with their own OAuth identity.
• A capability several clients need (Claude Code, Claude Desktop, Cursor, and an app's agent loop) behind one shared definition.

An MCP server is the wrong tool for teaching procedure. Packing a runbook into a tool description bloats every request and gives the model a worse version of what a skill would load only when needed.

Decision guide

Ask these questions in order:

1. Does the agent need to reach a system it cannot reach today? If no, write a skill.
2. Is there already a good CLI for that system (gh, aws, kubectl)? If yes, a skill that says which commands to run, with which flags, is often cheaper than an MCP server.
3. Does the action need its own credentials, per-user identity, or an audit trail? If yes, use an MCP server, and put it behind a gateway once more than one person uses it.
4. Does the agent also need your team's rules for using that access? If yes, add a skill on top.

Using skills and MCP together

The two compose well because they solve different halves of the problem. Three common patterns:

Code review. A GitHub MCP server, scoped to get_pull_request and list_files, gives the agent read access. A review-standards skill tells it what your team flags, what it ignores, and how to format comments. Neither works well alone: without the server the agent cannot see the PR, and without the skill it reviews against generic advice.

Database migrations. A Postgres MCP server with a read-only user lets the agent inspect the live schema. A db-migrations skill tells it to use the repo's migrate tool, create indexes concurrently, batch backfills by primary key range, and always write a rollback script.

Support triage. A CRM MCP server exposes search_contacts and get_contact. A support-triage skill defines the categories, escalation rules, and the tone of replies, and tells the agent never to call write tools without approval.

There is also convergence at the protocol level: the MCP project lists Skills over MCP as an extension for discovering and consuming structured agent instructions through MCP. For now, most teams install skills from git and connect tools through MCP, and the patterns above apply either way.

Security differences

Both expand what an agent does, but the risks differ:

• Skills are code-adjacent instructions that the agent follows with the user's permissions. Review them like code: no curl | sh, no sudo, no broad rm -rf, no reads of ~/.ssh or ~/.aws, every network call documented, and no text that tries to override the user's instructions. Read third-party skills in full before installing.
• MCP servers hold credentials and execute actions. Tool descriptions and tool results are both prompt input, so a malicious or compromised server can inject instructions. Allow-list individual tools per agent, require human approval for anything that writes, deletes, sends, pays, or deploys, move tokens off laptops, and pin server versions so a new release cannot change tool descriptions under you.

Running both across a team

The team-scale problems mirror each other. Skills drift when the same SKILL.md is copied into several repos. MCP configs drift when the same server is configured separately in Claude Code, Claude Desktop, Cursor, and app code, each with its own copy of the token.

Both fixes take the same shape, with one source of truth for each.

• Skills: keep cross-repo skills in one git repo, version them with SemVer, and install them with npx skills add your-org/team-skills -a claude-code codex cursor -y, which symlinks one canonical copy into each agent.
• MCP: register servers once on an MCP gateway that stores credentials server-side and exposes one /mcp endpoint, and give each person or agent a revocable key that sees only the tools it is granted.

Bifrost, an open-source AI gateway, does both from one deployment: its MCP gateway aggregates servers behind /mcp with per-virtual-key tool allow-lists, and its Skills Repository publishes immutable skill versions to Claude Code and Codex as a plugin marketplace. Connecting Claude Code to every approved MCP server becomes one command:

claude mcp add-json bifrost '{"type":"http","url":"http://localhost:8080/mcp","headers":{"Authorization":"Bearer sk-bf-your-virtual-key"}}'

Install the skills behind this post

Two open-source agent skills cover the practices in this post, one for each side.

agent-skills-for-teams writes descriptions that trigger, keeps skills small, versions and reviews them, and ships them to every coding agent with a rollback path.

• GitHub: github.com/build-with-ai-hq/agent-skills-for-teams
• skills.sh: skills.sh/build-with-ai-hq/agent-skills-for-teams

npx skills add build-with-ai-hq/agent-skills-for-teams

mcp-gateway-best-practices audits MCP setups, cuts the tool surface, locks down permissions and approvals, and centralizes servers behind a gateway.

• GitHub: github.com/build-with-ai-hq/mcp-gateway-best-practices
• skills.sh: skills.sh/build-with-ai-hq/mcp-gateway-best-practices

npx skills add build-with-ai-hq/mcp-gateway-best-practices

Install both into several agents at once with -a claude-code codex cursor -y. Then ask your agent "should this be a skill or an MCP server?" with your use case, or "audit our skills and MCP setup." The skills bring their own audit commands, so the agent inventories what you have before changing anything.

Related reading

• How to Create Claude Code Skills That Actually Trigger (SKILL.md Guide)
• What Is an MCP Gateway? When You Need One and How to Set It Up

FAQ

Can a skill call an MCP tool?

A skill cannot call anything by itself; it is instructions. But its body can tell the agent which MCP tools to use, in which order, and with which arguments. That is the most common way to combine them.

Do skills replace MCP?

No. Skills carry knowledge and procedure; MCP carries access. A skill can replace an MCP server only when a CLI the agent can already run covers the access you need.

Which uses fewer tokens, a skill or an MCP server?

Before use, a skill costs about 100 tokens of metadata. An MCP server costs its tool names and descriptions, plus full schemas on clients that do not defer them. Large tool catalogs are the bigger cost in most setups, which is why tool allow-lists and on-demand discovery matter.

Are skills safer than MCP servers?

They carry different risks. A skill with a bundled script can run code on the developer's machine, so it needs code review. An MCP server holds credentials and can take actions in other systems, so it needs tool allow-lists, approvals, and logging.