Skills vs MCP Servers vs Custom Instructions: When to Use Each
Three ways to give a coding agent more to work with, and they solve different problems. A plain test for choosing, what each costs in context, and where each one lives in Claude Code, Cursor and Codex.
If you use Claude Code, Cursor or Codex for long enough, you end up with three different places to put “stuff the agent should know”: custom instructions, skills and MCP servers. They overlap just enough to be confusing. People write a skill when a one-line instruction would do, or install an MCP server to teach the agent a procedure it could have read from a file.
Here’s the short way to tell them apart, then the detail.
The one-sentence version
- Custom instructions are facts and preferences that apply to almost everything you do in a project.
- A skill is a procedure for one kind of task, loaded only when that task comes up.
- An MCP server is a connection that lets the agent reach a system outside itself, such as an issue tracker, a database or a design file.
Put another way: instructions tell the agent how you work, a skill tells it how to do one job, and MCP gives it hands to reach something it otherwise couldn’t.
A quick test
Ask these in order and stop at the first yes.
- Does the agent need to read from or act on a system it can’t reach today? Live tickets, a production database, a Figma file, your calendar. That’s MCP. No amount of written instructions gives the agent access it doesn’t have.
- Is it a multi-step procedure for a specific kind of task? Writing release notes, reviewing a migration, preparing a PR. That’s a skill.
- Is it a fact or rule that should hold almost all the time? “Use pnpm.” “Run the tests before you commit.” “Never edit files in
dist/.” That’s a custom instruction.
Many real setups use all three at once. An MCP server connects the agent to your issue tracker, a skill describes how your team writes a ticket, and a line in your instructions file says which project key to use.
What each one costs
The three load differently, and that’s the practical reason to choose carefully.
Custom instructions load every time. Claude Code loads CLAUDE.md at the start of every conversation. Its docs suggest keeping each file under 200 lines, because longer files use more context and reduce how well Claude follows them. Codex reads AGENTS.md files before doing any work and, by default, stops adding them once the combined size reaches 32 KiB. Cursor puts an always-on rule’s contents at the start of the model’s context. Every line here is paid for in every session, whether it’s relevant or not.
A skill mostly waits. Under the Agent Skills specification, only each skill’s name and description load at startup, roughly 100 tokens. The full SKILL.md loads only when the agent decides a task matches. That’s why a long procedure belongs in a skill rather than in your instructions file. The Claude Code docs say exactly this: move a section of CLAUDE.md into a skill once it “has grown into a procedure rather than a fact”.
An MCP server’s cost depends on the client. The server describes its tools to the agent, and those descriptions take up space. Claude Code now uses tool search by default, which defers tool definitions until they’re needed, so only tool names and server instructions load at session start. Other clients and configurations may load more up front, so it’s worth checking what your tool does before connecting ten servers you rarely use.
Where each one lives
| Claude Code | Cursor | Codex | |
|---|---|---|---|
| Custom instructions | CLAUDE.md (project), ~/.claude/CLAUDE.md (you), CLAUDE.local.md (you, this project) |
.cursor/rules/*.mdc, AGENTS.md, User Rules in Customize |
AGENTS.md in the repo, ~/.codex/AGENTS.md (you) |
| Skills | .claude/skills/ or ~/.claude/skills/ |
.cursor/skills/ or .agents/skills/, plus Claude and Codex folders |
.agents/skills/ or ~/.agents/skills/ |
| MCP servers | .mcp.json (project), or claude mcp add |
.cursor/mcp.json (project) or ~/.cursor/mcp.json |
~/.codex/config.toml, or .codex/config.toml in trusted projects |
Two details save some confusion. Claude Code can now read AGENTS.md as your project instructions, but only when there’s no CLAUDE.md or CLAUDE.local.md in the working directory or above it. If both exist, it reads the CLAUDE.md files. And Cursor’s project rules must use the .mdc extension; a plain .md file in .cursor/rules is ignored. If you’d rather write plain Markdown, Cursor’s docs point you to AGENTS.md.
The skill folders are covered step by step in our install guide.
Cursor rules sit in between
Cursor’s rules are worth a special mention, because they blur the line between instructions and skills. A rule can be set to apply always, to apply when matching files are in context, to be pulled in by the agent when its description seems relevant, or only when you @-mention it.
So an “Apply Intelligently” rule with a good description behaves a lot like a skill. The difference is portability. A rule is a Cursor format. A SKILL.md follows an open standard that Claude Code and Codex read too. If a procedure is useful across tools, a skill is the better home. If it’s a Cursor-specific convention for one folder, a file-scoped rule is simpler.
Common mix-ups
Writing a skill for a one-line preference. “Always use British spelling” doesn’t need a folder and a description. Put it in your instructions.
Stuffing a procedure into CLAUDE.md or AGENTS.md. A 60-line release checklist in your instructions file gets loaded into every session, including the ones about CSS. Move it to a skill and it loads only when someone asks for release notes.
Using MCP to teach, not to connect. If a server’s only job is to hand the agent a block of text, a skill or a reference file does the same with nothing to run. Use MCP when there’s a live system on the other end.
Expecting instructions to enforce anything. Claude Code’s docs are direct about this: CLAUDE.md is context, not enforced configuration. If something must never happen, use the tool’s permission settings or a hook, not a sentence in a Markdown file.
A word on trust
Each of these can change what an agent does, and two can run things. A skill can include scripts, and in Claude Code it can pre-approve tools. An MCP server can reach external services and run code on your behalf. Cursor’s docs advise installing servers only from trusted sources and using API keys with the smallest permissions that work. Claude Code’s docs warn that servers which fetch outside content can expose you to prompt injection. Read what you install, whichever of the three it is.
Putting it together
If you’re setting up a project from scratch, a sensible order is:
- Start with a short instructions file: how to build, how to test, the two or three rules people keep forgetting.
- When you notice yourself pasting the same multi-step instructions into chat, turn them into a skill. Our guide to writing your first SKILL.md walks through it.
- Add an MCP server when the agent needs to reach a system it can’t get to on its own, and only the servers you’ll actually use.
Keep each one doing its own job and they stay easy to maintain. If you want ready-made skills to start from, browse the Skillaisle library.
Sources
- Model Context Protocol: What is MCP?
- Agent Skills: Specification
- Claude Code docs: How Claude remembers your project (CLAUDE.md)
- Claude Code docs: Extend Claude with skills
- Claude Code docs: Connect Claude Code to tools via MCP
- Cursor docs: Rules
- Cursor docs: Model Context Protocol
- OpenAI docs: Custom instructions with AGENTS.md
- OpenAI docs: Codex and MCP
Products change quickly. If something here no longer matches what you see, the official page above is the reference.
Related on Skillaisle
Want the setup steps? Browse the Learn guides or walk the skills aisle.