Skills Don't Replace MCPs

I keep seeing people ask whether skills replace MCPs. They don't. They solve completely different problems. The confusion comes from how vendors talk about them — skills get pitched as the productivity win, MCPs get pitched as the integration layer, and nobody bothers explaining how the two relate.

I use Claude Code, Codex, and Droid every day. All three support skills, MCPs, slash commands, and CLIs in some form. Once you see what each one actually does, the overlap vanishes.

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. I have 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 my 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" — pull that out and make it a deploy skill instead. Same result, but the instructions don't load into context until the skill is activated.

Skills compose — they can call each other. My "take over" skill calls review, then commit, then deploy. I hand off and move on to the next thing instead of babysitting the agent through each step. I also have a "review+fix" skill that calls itself in a loop until there are no more issues.

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. Think of them as APIs for agents. 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. Slash commands are 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 what most people miss: coding agents already have shell access. They can run curl, gh, psql, aws, docker — whatever you have installed. The agentic part: they'll 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.

I reach for CLIs first because:

• 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 lighter on context — the agent already knows how to use them without loading tool definitions. MCPs do have one edge: more formalized access control baked in. But in practice, CLIs win most of the time.

MCPs make sense when there's no good CLI equivalent (browser automation, IDE integration), when you need stateful connections or streaming, or when wrapping something 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 operate at 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 handle orchestration. MCPs and CLIs are the tools that orchestration calls.

The reason skills get pushed so hard by vendors: 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. 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 foundation. 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 — 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.