Skills vs MCP: Extending Coding Agents

By 2026 there are two standard, complementary surfaces for extending what a coding agent can do, and confusing them produces bad builds in both directions. MCP (Model Context Protocol) is a connection protocol — it defines how an agent reaches outside the model to call an API, query a database, or drive another system. Skills are a knowledge format — a folder of instructions, scripts, and examples that teaches an agent how to approach a category of work. The crisp version: MCP gives the agent access; skills give the agent judgment about what to do with that access.

Where Each Came From, and Where Each Stands

MCP — introduced by Anthropic in late 2024, and by 2026 the default way agents talk to external systems: on the order of 97 million downloads and first-party adoption by Anthropic, OpenAI, Google, and Microsoft. If a coding agent is reading your issue tracker, querying your database, or pushing to your wiki, it is almost certainly speaking MCP.
Skills — launched by Anthropic in October 2025, published as an open cross-platform standard in December 2025. A skill written once in the SKILL.md format runs on any compatible client — adoption spans Claude Code, Cursor, Gemini CLI, GitHub Copilot, OpenAI Codex, Goose, and Letta — which turned skills from a vendor feature into a portable team asset.

The Anatomy of a Skill

A skill is a directory with a SKILL.md at its root: YAML frontmatter carrying a name and a one-line description, then a markdown body of instructions, optionally alongside helper scripts and reference files. The economics are the point — progressive disclosure: only the name and description enter context at session start; the body loads when the skill actually triggers. A 2,500-token skill body behind a 60-token header defers ~98% of its context cost until the moment it pays for itself — which is what makes a library of dozens of skills viable where a monolithic instruction file is not (see ContextEngineeringForCodingAgents).

Good skill material is any procedure you'd otherwise re-explain: your release process, a review checklist, the deployment runbook, house style for a document type, the workflow for a recurring analysis. The deeper format details and authoring craft live in CustomSkillsArchitecture and its sibling pages (SkillComposition, SkillDebugging).

The Decision Framework

You need…	Build
Access to an external system (API, DB, SaaS) with auth, structured calls, live data	MCP server
A procedure followed consistently (process, checklist, house method)	Skill
A rule active in every session of one repo (conventions, build commands)	Instruction file (CLAUDE.md / AGENTS.md)
A deterministic transformation with no judgment in the middle	Plain script the agent (or CI) runs

The boundary cases are where the framework earns its keep:

Instruction file vs skill: always-on and repo-scoped → instruction file; on-demand, task-scoped, or shared across repos and tools → skill. Instruction files are a per-session tax; skills are pay-per-use.
Skill vs script: if no step needs model judgment, a skill is overhead — write a script. The best skills wrap scripts: judgment about when and how, delegating the deterministic middle to code.
MCP vs CLI: if a good CLI exists and the agent has a shell, the CLI often suffices — an MCP server that thinly wraps a CLI mostly adds surface to maintain. MCP wins when there is auth to broker, state to manage, structured schemas worth exposing, or non-shell clients to serve. Design guidance: GoodMcpDesign.

The Power Combination

The strongest pattern composes them: an MCP server for access, a skill for the method. The MCP server exposes what can be done (tools to query, write, verify); the skill encodes what should be done (the order, the gates, the verification loop, the failure handling). Example shape: a knowledge-base MCP server exposes write/read/verify tools, and a content-authoring skill teaches the agent the workflow — survey before writing, lint after writing, live-check retrieval afterward. The MCP surface alone leaves every session to improvise its method; the skill alone has knowledge but no hands.

Anti-Patterns

The skill that is just documentation — no trigger, no procedure, only facts. Facts belong in a knowledge base or reference file; skills are for how.
The MCP server nobody needed — wrapping something a two-line shell call already did, at the cost of another auth path to maintain and another tool list to pollute.
Fifty always-on skills — header cost times fifty is a real session-start tax; consolidate overlapping skills and let genuinely rare procedures live as linked docs instead.
Skill/instruction contradiction — the same rule stated differently in CLAUDE.md and a skill; the agent resolves it unpredictably. One source of truth per rule.