Skills Don't Replace MCPs

Sometimes people ask how skills replace MCPs. They don't. They do completely different things. The confusion comes from vendor messaging — skills get pushed as the big productivity gain, MCPs get hyped as the integration layer, and nobody explains how they relate.

I use Claude Code, Codex, and Droid daily. All three support skills, MCPs, slash commands, and CLIs in some combination. Once you see what each one does, there's no confusion.

Skills

Skills are Markdown files — a name, a description, and a prompt body. When you tell the agent to do something that matches a skill's description, it picks up the skill and follows the instructions.

They define behavior. A "commit" skill that stages changes and writes a concise commit message. A "review" skill that checks dirty diffs for issues. A "writing-voice" skill that tells the agent how to write in your style.

A way to think about it: anywhere you'd write in AGENTS.md something like "when I say deploy, push to GitHub and run scripts/deploy.sh" — you pull that out and make it a deploy skill instead. Achieves the same result, but with benefits such as not loading into your context until the skill is activated.

Skills compose — they can call each other. I have a "take over" skill that calls review, then commit, then deploy. This frees me up mentally to move on to the next task rather than handhold the agent or come back to check if deployment is done. I have a "review+fix" skill that calls itself, looping until there are no more issues to fix.

Same Markdown format across Claude Code, Codex, and Droid.

MCPs

MCPs (Model Context Protocol) expose external systems to the agent as callable tools. The agent sees them as functions: "read browser console logs," "query this database," "fetch Sentry issues."

They define capabilities, not behavior. Another way to think of it: they're APIs for agents to call. An MCP doesn't tell the agent when or why to use a tool — it just makes the tool available.

All three agents support MCP servers.

Slash Commands

You type /commit or /review and the agent runs a predefined prompt. They're the earlier incarnation of skills — same Markdown format, but you invoke them manually, the agent won't pick them up automatically based on context, and they can't easily call other slash commands.

Same format across Claude Code, Codex, and Droid.

CLIs

Here's the thing most people miss: coding agents already have shell access. They can run curl, gh, psql, aws, docker — whatever you have installed. And the agentic part: they can install CLIs for you before running them. A lot of what you'd build an MCP for, you can already do with a CLI.

GitHub? gh. Database query? psql. Hit an API? curl.

CLIs are often the better choice:

• No setup — if it's installed, it works
• Better documented — extensive docs the agent already knows
• More flexible — full CLI interface, not a subset exposed through MCP
• Easier to debug — you can run the same commands yourself

CLIs are also more efficient for context — the agent already knows how to use them without loading tool definitions. MCPs do have one advantage: more formalized access control baked in. But CLIs are almost always the better choice.

MCPs make sense when there's no good CLI equivalent (browser automation, IDE integration), when you need stateful connections or streaming, or when wrapping it in a tool interface genuinely simplifies things. For everything else, a CLI is simpler.

How They Fit Together

Skills and MCPs aren't competing. They're different layers:

• Skills = what to do (behavior, process, orchestration)
• MCPs and CLIs = how to interact with external systems (tools, capabilities)

A skill can tell the agent to use a specific CLI or MCP as part of its workflow. Skills are orchestration. MCPs and CLIs are the tools the orchestration uses.

The reason skills get pushed so hard: for most workflows, defining the behavior is the bigger gain. Most agents already have the tools they need — file system, shell, git. What they lack is knowing your preferred process.

This is also why AGENTS.md matters so much. It tells the agent how your project works — what commands to run, what patterns to follow, what to avoid. Skills build on top of that. Stacknaut ships with both: an AGENTS.md tuned for the starter kit's stack, and a set of composable skills for common workflows like commit, review, and deploy. When I start a new project, the agent already knows how I work.

Plugins

Plugins are how skills get bundled and distributed via registries. Think of them as packages of skills you can install — similar to how npm works for libraries. Both Claude Code and Droid support them.

Quick Reference

Concept	What it does	How it's triggered
Skills	Defines behavior and workflow	Auto-triggered by context or manual
MCPs	Exposes external tools and APIs	Agent calls them as needed
Slash commands	Runs a predefined prompt	Manual — user types the command
CLIs	Runs shell commands	Agent uses shell access

Skills tell the agent what to do. MCPs, CLIs, and slash commands give it ways to do it. They're complementary.