What is the difference between skills and MCP?
MCP gives an agent access. Skills give it a method. An MCP server connects an agent like Claude or Codex to something outside it: a database, Linear, GitHub, your calendar. A skill is a folder of instructions that teaches the agent how to do a particular job, such as triaging bugs or writing release notes, and it can include scripts.
They aren't rivals. Anthropic's own one-line summary, from its Skills explained post, is "MCP connects Claude to data; Skills teach Claude what to do with that data." Most real setups use both: MCP to reach the system, a skill to say how your team works with it.
What each one is
An Agent Skill is a folder with a SKILL.md file: a name, a description and Markdown instructions, plus optional scripts and reference files. The agent reads only the name and description until a task matches, then loads the rest. Skills follow the open Agent Skills standard and work in Claude, Codex, Cursor and other agents. There's nothing to run: a skill is just files.
An MCP server is a program that speaks the Model Context Protocol, an open standard for connecting AI applications to outside systems. The server exposes tools (actions the agent can take), resources (data it can read) and prompts. The agent connects to it locally or over the network and calls its tools while it works. The MCP site describes it as "a USB-C port for AI applications".
Side by side
| Agent Skills | MCP servers | |
|---|---|---|
| What it is | Files: instructions, scripts, references | A running program with tools |
| What it adds | Know-how: steps, rules, formats, examples | Access: live data and actions in other systems |
| How it loads | Name and description at startup, full text on match | Connected for the session; tools called as needed |
| Idle context cost | About 100 tokens per skill | Depends on the client; Claude Code defers tool definitions by default |
| Setup | Copy a folder | Install or point to a server, often with sign-in |
| Runs code? | Can bundle scripts the agent runs | Runs its own code, locally or remotely |
| Best for | Repeatable procedures and house style | Data and actions the agent can't reach otherwise |
| Main risk | Hidden instructions or scripts in the folder | Broad access to real accounts and data |
| Changes when | You edit the files | The outside system's data changes |
Do skills use less context than MCP?
Skills use little context by design, but the gap with MCP is smaller now. The most common argument for skills over MCP is context. It used to be a strong one: early MCP clients loaded every tool definition from every server into context up front, so a few big servers could use a large share of the window before you typed anything.
Skills avoid that by design. Only the name and description, roughly 100 tokens per skill according to Anthropic's Agent Skills overview, load until a skill is needed.
The gap is smaller now. Claude Code's MCP docs describe tool search, on by default, which defers tool definitions so that only tool names and server instructions load at session start. Other clients handle this differently, so check yours. If you connect many servers to a client that loads everything up front, you'll still feel it.
When to use a skill
Pick a skill when the agent already has what it needs and is missing the know-how.
- Your team's way of doing something: how you write commit messages, PR descriptions, release notes or incident reports.
- A multi-step procedure that should run the same way each time, like a migration checklist or a release process.
- Reference material the agent should consult only sometimes: a style guide, an API cheat sheet, a database schema.
- Work a local CLI already covers. If the agent can run
gh,psqlorawsin your terminal with your existing credentials, a skill that explains how to use them well is often all you need. - Something you want to share as plain files in a Git repo, reviewable like code.
When to use an MCP server
Pick MCP when the agent can't reach the system at all without it.
- Remote services with sign-in, like Notion, Linear, Slack or Google Drive, where the server handles OAuth and the API.
- Apps without a terminal, such as the Claude app on the web, where the agent can't run your CLI tools. There, MCP-based connectors are the way to reach outside systems.
- Structured actions you want to permission one by one, such as "create issue" or "run read-only query", instead of open shell access.
- Live data that changes between calls: ticket queues, metrics, production logs.
- One integration shared by many agents and many users, maintained in one place.
How do skills and MCP work together?
The strongest setup is a skill that tells the agent how to use an MCP server. The MCP server provides the tools; the skill provides the order, the filters and the output format your team wants.
Here's a skill that turns a Linear MCP server into a weekly bug report:
---
name: weekly-bug-report
description: Build the weekly bug report from Linear, covering new bugs, bugs
fixed and anything blocking a release. Use when the user asks for the bug report,
weekly bugs or a bug summary.
---
# Weekly bug report
Use the Linear MCP server's tools. Call them by their full name,
server first, so the right server is used.
1. List issues with the label "bug" created in the last 7 days.
2. List bugs moved to Done in the last 7 days.
3. Flag any open bug with priority Urgent or a "release-blocker" label.
4. Write the report:
- **New** (count, then one line each: title, team, priority)
- **Fixed** (count, then one line each)
- **Blocking release** (each with owner and age in days)
5. Keep it under 300 words. Skip bugs labelled "duplicate" or "wontfix".
If the Linear tools are not available, say so and stop.
Writing the full tool name with its server comes from Anthropic's authoring best practices, which warn that without the server prefix Claude may fail to find the tool when several servers are connected. Codex has a matching idea: a skill's optional agents/openai.yaml can declare the MCP server it depends on.
Can a skill replace an MCP server?
Sometimes, and it's worth checking before you add a server. If you work in Claude Code or Codex, the agent can run command line tools. A short skill that says "use gh pr list --json to find open PRs, then..." gives you GitHub access with no MCP server, using the gh login you already have.
That works well when a good CLI exists, you're working in a terminal agent, and you're comfortable with the agent running shell commands. It doesn't work in the Claude app, for services without a CLI, or when you need fine-grained control over each action. In those cases, MCP is the right tool, and a skill on top of it is still useful.
Security: both need trust
Neither option is safe by default. A skill can hide instructions or scripts that do something other than what its description says, so read every file in a skill before you turn it on. An MCP server acts with whatever access you grant it, often to real accounts, so install servers only from sources you trust and grant the narrowest scopes they offer. In Claude Code, project-scoped MCP servers ask for approval before first use.
Setting up each in Claude Code
# add a remote MCP server (HTTP is the recommended transport)
claude mcp add --transport http notion https://mcp.notion.com/mcp
# add a skill: it's just a folder
mkdir -p ~/.claude/skills/weekly-bug-report
# then save SKILL.md inside it
For more on servers, see Claude Code MCP. For more on skills, see Claude Code skills and the broader Claude Skills guide.
Where Kipt fits
Kipt handles the skills side. It keeps your prompts and skills as Markdown in a private GitHub repo you own, turns a saved prompt into a SKILL.md with Promote to skill, and installs the whole library into Claude Code or Codex with one npx skills add command. Your MCP servers stay configured in each agent as usual; your skills tell the agent how to use them. To convert a single prompt now, try the free SKILL.md generator.