← Back to blog

Skills vs MCP: The Shift Reshaping AI DevOps Tools

The AI DevOps toolkit is shifting from MCP to Skills. Learn why this simpler abstraction is winning—and what it means for teams that invested big.

Skills vs MCP: The Shift Reshaping AI DevOps Tools

Eighteen months ago, MCP was the answer to everything. Every AI demo, every chatbot connector, every integration between an assistant and your DevOps tools ran on the Model Context Protocol under the hood. Then, quietly, a simpler idea started eating its lunch: Skills — plain folders of instructions that an AI agent reads only when it needs them. Teams that wired their entire toolchain to MCP servers are now asking a fair question: did we bet on the wrong abstraction?

Short answer: no — but you probably over-bought. Here is the honest breakdown of what happened, why it matters for your budget, and how the two actually fit together.

Why MCP Won the First Round

The Model Context Protocol shipped from Anthropic in November 2024 as an open standard. The pitch was simple and correct: before MCP, every AI integration was a custom adapter. Connecting one model to five tools meant five bespoke integrations; three models and five tools meant fifteen. MCP replaced that N×M mess with one protocol — a USB-C port for AI applications.

The industry agreed fast. OpenAI adopted MCP in March 2025. Google DeepMind followed. Within a year there were thousands of community MCP servers covering everything from GitHub and Slack to Kubernetes monitoring tools and cloud billing APIs. If you wanted your AI assistant to query Grafana, file a Jira ticket, or read a Postgres database, there was probably an MCP server for it.

That part of the story hasn't changed. MCP solved connectivity, and it still does. What changed is that teams discovered connectivity was only half the problem — and the expensive half was hiding elsewhere.

The Hidden Bill: Context Is Not Free

Every MCP server you connect loads its tool definitions into the model's context window — up front, on every session, whether the agent uses those tools or not.

Real numbers: Anthropic's own engineering team documented the problem in late 2025. Agents connected to many MCP servers were burning tens of thousands of tokens on tool definitions before reading a single user request. In one worked example, a workflow that consumed roughly 150,000 tokens through direct tool calls dropped to about 2,000 tokens when restructured — a 98.7% reduction. At API prices, that is not a rounding error. It is the difference between an AI workflow that costs cents per run and one that costs dollars, multiplied across every run, every day.

There is a second cost that shows up before the invoice does: model performance. Context windows are finite, and models reason worse when their context is stuffed with definitions for 40 tools they will never call. If you connect an agent to your full stack of DevOps automation tools — CI/CD, monitoring, ticketing, cloud consoles — the agent starts every conversation already carrying dead weight. We covered why this matters in depth in our piece on context engineering vs prompt engineering: managing what enters the context window is now the core discipline of building with AI, and MCP's default behavior works against it.

Put simply: MCP made connecting tools easy and made using many tools expensive.

Enter Skills: The Employee Handbook Model

In October 2025, Anthropic released Agent Skills — and the design is almost embarrassingly simple. A Skill is a folder. Inside is a markdown file with instructions, optionally accompanied by scripts and reference documents. That's the whole spec.

The clever part is progressive disclosure. At startup, the agent sees only each Skill's name and a one-line description — a few dozen tokens each. The full instructions load only when the task actually calls for them. Deeper reference files load only if the Skill's instructions point to them and the agent decides it needs them.

The analogy that fits: MCP is the office phone system — live lines to every external service. A Skill is the employee handbook chapter that says how to actually run the deployment: which checks come first, what the rollback procedure is, who signs off, which numbers to call in what order. New employees don't memorize the whole handbook on day one; they check the table of contents and read the chapter when the situation arises. That is exactly what progressive disclosure does for an agent.

Simon Willison, one of the most-read independent voices on AI tooling, argued that Skills may be a bigger deal than MCP — precisely because they are so cheap and so portable. A Skill is markdown. It works across any agent harness that can read files. There is no server to deploy, no protocol handshake, no OAuth flow to maintain.

Skills vs MCP: The Actual Comparison

The framing "Skills vs MCP" is popular and slightly wrong. They solve different problems:

MCP Skills
What it is Protocol connecting agents to external systems Folder of instructions loaded on demand
Solves Connectivity — live data, APIs, actions Procedure — how to do a task correctly
Context cost Tool definitions load up front, per server Name + description only, until needed
Infrastructure Server process, transport, auth None — files on disk
Best at Real-time queries, authenticated actions, streaming Encoding workflows, standards, runbooks
Weak at Token economy at scale Doing anything without an execution environment

The pattern that is winning in practice: a thin MCP layer for the connections that genuinely need live access, and Skills for everything that is knowledge rather than connectivity.

Concrete example from the DevOps world: an incident-response agent needs an MCP connection to your monitoring stack to pull live alerts and metrics — that is connectivity, no file can replace it. But how your team triages — severity definitions, escalation order, which dashboards to check before paging anyone, the post-incident template — that is a runbook, and encoding it as a Skill costs near-zero tokens until an incident actually fires. Teams that put all of that into MCP tool descriptions were paying for it in every single session.

What This Means for DevOps Automation Tools

For teams evaluating AI-assisted operations, the evolution changes the shopping list:

Audit your MCP surface. If your agent is connected to ten servers and routinely uses two, you are paying context tax on eight. Disconnect what isn't earning its tokens, or move to a setup where tool definitions load on demand.

Move runbooks into Skills. Deployment procedures, rollback checklists, code-review standards, security policies for DevOps security tools — anything currently living in a wiki that an agent should follow is a Skill candidate. The format is markdown; the migration cost is measured in hours, not sprints.

Treat Skills as code. A Skill that can execute scripts is an execution risk, the same way a CI pipeline definition is. Version them in git, review changes, and never install third-party Skills you haven't read — the same discipline you already apply to Kubernetes operators and CI plugins. This is the one place where MCP's heavier infrastructure was accidentally a feature: a protocol boundary is easier to gate than a folder of instructions.

Don't rip out MCP. Live integrations — querying kubernetes monitoring tools, posting to chat, reading tickets — still need a connection standard, and MCP remains the industry's shared answer with backing from Anthropic, OpenAI, and Google. The correction is about proportion, not replacement.

The Vibe Coding Connection

The same evolution explains a shift in how people build software with AI. Early vibe coding setups leaned on maximal tooling: connect everything, give the model every capability, hope for the best. The results were expensive and erratic — a pattern we dissected in what actually survives the vibe coding hype.

The setups that work now look like Skills-thinking applied to development: small, well-scoped context; explicit instructions for the project's conventions; tools connected only when needed. If you are figuring out how to start vibe coding productively, that is the actual lesson — the best vibe coding tools are not the ones with the most connectors, but the ones that manage context most aggressively. It is also why we keep insisting that building AI agents still requires engineering judgment: deciding what an agent should know, when, is a design decision no protocol makes for you.

Honest Take: What We'd Bet On

Honest take: Skills are not a revolution in capability — an agent with a Skill can't do anything it couldn't theoretically do before. They are a revolution in economics and maintainability, which for a business is usually the revolution that matters. Markdown files that any team member can read, diff, and edit will outlive any integration pattern that requires dedicated infrastructure to answer the question "how do we do deployments here?"

At the same time, the MCP ecosystem's scale is real. Thousands of servers, three major AI vendors behind the standard, and genuine problems — auth, streaming, live state — that files cannot solve. Betting against MCP entirely would be as wrong as betting everything on it was in 2025.

Here is what we recommend: connectivity through MCP, knowledge through Skills, and a monthly look at your token bills to check the ratio is right.

Key Takeaway for Business

Key takeaway for business:

  1. MCP solved connections; Skills solved cost. MCP remains the standard for wiring AI into your DevOps tools, but loading every tool definition up front was burning tens of thousands of tokens per session. Skills load in dozens of tokens until actually used — documented restructurings have cut workflow token usage by over 98%.
  2. Your runbooks are your moat. The durable asset is not the integration — it's the encoded knowledge of how your team operates. Skills make that knowledge portable, versionable, and cheap. Start moving it out of wikis and into agent-readable form now.
  3. Govern Skills like code, not like docs. They can execute scripts. Review them, version them, and gate third-party ones — the same rules you already enforce for CI pipelines and cluster operators.

This article is based on publicly available sources and may contain inaccuracies.

Related articles

✦SqueezeAI
  1. MCP replaced N×M custom integrations with a single protocol, giving any AI agent a standard connection point to any tool — the connectivity problem it solved remains valid.
  2. Every connected MCP server loads its tool definitions into the model's context window on every session, regardless of whether those tools are called. Anthropic's own data shows restructuring one workflow cut token usage from ~150,000 to ~2,000 — a 98.7% reduction — which translates directly to per-run cost at API pricing.
  3. Skills load instructions into context only when the agent actually needs them, avoiding the upfront token overhead that accumulates when many MCP servers are connected simultaneously.

Powered by B1KEY