Claude Skills vs MCP: Which to Use, and Why a SaaS Ships Both

Claude Skills vs MCP is a choice between teaching and access. Use a Skill when the agent can already reach everything it needs and keeps doing the job the wrong way: the Skill holds your procedure, your output format and any script that should run the same way every time. Use an MCP server when the agent needs live data or must act in a system it cannot otherwise reach. Use both when the job is a procedure over a live system, which is the usual case for a SaaS product. If you are unsure, write the Skill first: it is one markdown file, and it will show you which calls the procedure needs that the agent cannot make.

Everything below was checked on 2026-10-07 against Anthropic's documentation and the MCP specification (revision 2026-07-28), and the token figures are our own measurements on our own server and skills.

What is a Claude Skill, exactly?

A Skill is a directory with one required file. SKILL.md opens with YAML frontmatter that carries two required fields: name (up to 64 characters, lowercase letters, numbers and hyphens, and it may not contain "anthropic" or "claude") and description (up to 1,024 characters). The markdown body below it is the procedure. Next to it you can put more markdown files, reference data and scripts.

The mechanism that makes Skills cheap is progressive disclosure, and Anthropic's Agent Skills documentation describes it in three levels. At startup only the name and description of every installed Skill go into the system prompt, about 100 tokens each. When a request matches a description, Claude reads the body of SKILL.md from the filesystem; Anthropic's guidance is to keep it under 5,000 tokens. Anything else in the folder loads only when the body points to it, and scripts run through bash so only their output enters the context, never their code.

Two consequences follow. The description is a classifier: Claude decides whether to open the Skill by matching the request against that one paragraph, so it has to say both what the Skill does and when to use it, in the words a user would type. And a Skill can carry a lot of material at no cost, because a reference file nobody needs this time is never read.

Skills launched in Claude on 16 October 2025 and became an open standard on 18 December 2025. The client list on agentskills.io (read 2026-10-07) includes Claude Code, Cursor, GitHub Copilot, VS Code, Gemini CLI, OpenAI Codex, Goose and OpenCode, so "Claude Skills" is now mostly a name for where the format came from.

What is an MCP server, exactly?

The Model Context Protocol connects an AI application (the host, such as Claude Code or VS Code) to servers that provide context. The host opens one client connection per server, and the two talk JSON-RPC 2.0. A server can offer three kinds of thing: tools the model calls, resources it reads, and prompts the user invokes as templates. The client discovers them with tools/list and its siblings, and the host passes the tool definitions to the model, which then decides when to call them.

There are two standard transports. Stdio runs the server as a local process on the user's machine and suits developer tools. Streamable HTTP runs it remotely, so one deployment serves many clients; this is the transport a SaaS product uses. The older SSE transport is deprecated, and Claude Code marks it so in its own setup docs.

The specification keeps moving, and anyone building a server today should read the 2026-07-28 revision rather than a tutorial from last year. It makes the protocol stateless: every request carries its protocol version and capabilities, and servers advertise what they support through a mandatory server/discover request. It deprecates sampling (servers asking the client's model for completions). And in the authorization spec it deprecates dynamic client registration in favour of OAuth Client ID Metadata Documents, keeping DCR only for backward compatibility.

Where does each one actually run?

Where a piece runs decides what it can reach, so check this first.

A Skill runs wherever the agent runs, with exactly the access that environment has. Anthropic's documentation lists the differences by surface. On the Claude API, Skills run inside the code execution container with no network access and no runtime package installation. On claude.ai, network access ranges from full to none depending on user and admin settings. In Claude Code, a Skill's scripts have the same network access as any other program on your computer.

An MCP server runs in its own process. A remote server runs on the vendor's infrastructure with the vendor's own access to its database and APIs; the agent sends a request and gets a result back. A stdio server runs on the user's machine with the user's credentials from the environment.

So the question "can a Skill do what my MCP server does?" has a surface-dependent answer. In Claude Code, a Skill whose script calls your API with a key from the environment works. On the Claude API, the same Skill cannot reach your API at all. For a product used by people you do not control, from clients you do not choose, the MCP server is the part that works in any MCP-capable client.

Sharing differs too. Custom Skills do not sync between Claude surfaces: an upload to claude.ai is personal to that user, an upload through the API is shared with the workspace, and Claude Code reads ~/.claude/skills/ or the project's .claude/skills/. A remote MCP server is one URL that every client connects to.

Which costs more context, a Skill or an MCP server?

We measured both on our own artefacts with Anthropic's token-counting endpoint on 2026-10-07 (model claude-sonnet-4-5):

• The INITE visibility MCP server exposes three tools (analyze_site, get_analysis, match_tools). Sending their definitions adds 998 input tokens to a request. One tool alone adds 660, because the API inserts a fixed tool-use preamble as soon as any tool is present; the second and third added 103 and 235.
• Our published skill that drives the same server, inite-ai-visibility-audit, costs 69 tokens of metadata and 636 tokens for the whole SKILL.md file, frontmatter included, once loaded.
• Two of our internal writing skills cost 89 and 127 tokens of metadata. Their full bodies are 2,399 and 6,769 tokens, and the second is over Anthropic's 5,000-token guidance, which is a reason to move part of it into a reference file.

At scale the gap is wide. Anthropic's tool search documentation gives about 55,000 tokens of definitions for a five-server setup (GitHub, Slack, Sentry, Grafana and Splunk) and says Claude's tool selection degrades past 30 to 50 available tools. Its fix is to defer loading and let Claude search for the three to five tools a request needs, which Anthropic says cuts definition tokens by more than 85 percent. Claude Code's MCP documentation says tool search is on by default from version 2.1.232.

Results cost context as well. The same Claude Code page says it warns when a single MCP tool result passes 10,000 tokens and caps it at 25,000 by default. A Skill's script returns only its output, so a script that prints "validation passed" costs a few tokens.

Can a Skill replace an MCP server, or the other way round?

A Skill can replace an MCP server only where the agent's environment already has the access, which in practice means Claude Code on a machine holding the credentials. The LlamaIndex team, writing about their own agent builder, put the trade-off as predictable execution through MCP against interpreted instructions through Skills: a tool call either works or fails, while a Skill can be misread.

An MCP server cannot replace a Skill. It can describe each tool, and a good description says when to call it, but it has no place for "call this, then that, check the result, and format the answer as a punch list for a marketing lead". Anthropic's own rule, from its December 2025 post on Skills and MCP, is the cleanest: "If you're explaining how to do something, that's a skill. If you need Claude to access something, that's MCP." The same post notes that one Skill can coordinate several MCP servers and one server can support many Skills.

When should you use both?

Whenever the job has steps and at least one step touches a live system. A weekly report is one example: MCP connects the database and the document store, and the Skill holds the normalisation rules and the template. Another is anything with a fixed sequence, such as "start the run, wait, read the result, then explain it to a non-technical owner", where the server alone would leave the agent guessing the order.

Our own pair works that way. The MCP server starts an audit and returns a run id; a second tool reads the result about a minute later. The Skill tells the agent when an audit is the right answer, that the two calls go in that order, and how to read the score back to the person who asked. An agent holding only the tool list has to infer the order from two descriptions; an agent holding only the Skill would read about an audit it has no way to start.

What should a SaaS vendor ship to become AI-native?

For a SaaS product the comparison above resolves into a short list. Most agents call tools instead of opening your dashboard. That shift is what the phrase AI-native points at, and the two standards are what make it concrete.

The build plan, week by week, is in the 90-day MCP server plan. The browser side of the same problem, making your interface legible to computer-use agents, is in browser-agent-ready SaaS. Whether your site is readable to the assistants that would recommend your product in the first place is what the free AI visibility check measures.

What usually goes wrong?

• Vague tool descriptions. The model never picks the tool. Write descriptions with verbs, inputs and a sentence on when to use it.
• Unbounded outputs. One call fills the context. Cap, paginate, or return a summary with a link.
• Too many tools. Past 30 to 50 tools, selection gets worse. Merge near-duplicates and namespace the rest (billing_, reports_) so tool search can find a group.
• API keys instead of OAuth. Every install needs a manual trip to a config file.
• A server without a Skill. Calls happen in the wrong order, and the answer comes back in the wrong shape.
• A Skill that assumes network access. It works in Claude Code and fails on the API.
• A generic Skill description. The Skill is never opened, because nothing in the request matches it.
• Installing Skills from strangers. Anthropic's documentation says to treat a Skill like installed software: a malicious one can direct the agent to run code or send data out. Audit every file before use. Anthropic also notes that Agent Skills are not covered by zero-data-retention arrangements.

For the governance side, who approves which actions an agent may take on your data, see human-in-the-loop for AI agents; for the platform pattern behind shipping one server per product, see one engine, many skins.

How do you choose?

Ask two questions in order. First: does the agent need something it cannot reach from where it runs, such as live data, an action in another product, or anything behind a login? If yes, you need an MCP server, and on the Claude API or in clients you do not control, a Skill cannot stand in for it. Second: does the job have an order, a format or a rule the agent keeps getting wrong? If yes, you need a Skill. Two yeses mean both.