Claude Code - Tools Primer

Note: This blog post was generated through a conversation with Claude based on my explorations of Claude Code’s architecture. You can read the full conversation here to see how we worked through these ideas together. The thoughts and arguments are mine, but Claude helped me articulate and structure them.

Let’s set the stage. Claude Code has been making waves in the agentic coding space. But if you dive into it, you’ll quickly encounter a constellation of concepts: Commands, Skills, Agents (Subagents), and MCP Servers. The marketing materials make them all sound essential. The reality? It’s more nuanced than that.

By now I have spent some time exploring what these tools actually do, when you should use each one, and more importantly, when you shouldn’t. What I found surprised me: the simplest solution is often the best one, and the MCP hype might be leading folks down unnecessarily complex paths.

The Four Concepts

Let me break down what Claude Code actually gives you:

Commands (Slash Commands) - These are your keyboard shortcuts on steroids. You manually trigger them with /command-name. Think /commit, /test, or custom deployment scripts. They’re explicit, predictable, and completely under your control.

Skills - Now this is interesting. Skills are folders containing instructions, scripts, and resources that Claude automatically discovers and loads when relevant. They use “progressive disclosure” - only loading what’s needed when it’s needed. The key word here is automatic. Claude figures out when to use them.

Agents (Subagents) - Specialized AI assistants with their own isolated context windows and tool permissions. They handle discrete tasks independently - code review, test generation, debugging. Think of them as specialized team members you can delegate work to.

MCP Servers - The Model Context Protocol. A universal connection layer for external tools and data sources. Think GitHub, databases, Google Drive, Slack. The marketing pitch? It’s like USB-C for AI.

The Question Nobody Asks

Here’s where it gets interesting. After understanding these concepts, a developer asked me a really good question:

“Wouldn’t it be better to use Skills (with command line tools) than MCP servers?”

This is the right question. Because when you look at what MCP actually does, versus what you can accomplish with a Skill that runs bash commands or Python scripts … well, there’s a lot of overlap.

When Skills Win

For most local development tasks, Skills with command-line tools are simpler and better. Consider:

• File manipulation - bash commands work fine
• Git operations - git CLI is comprehensive
• Running tests/linters - standard tooling
• Data transformations - Python/bash scripts
• Text processing - grep/awk/sed

All of this can live in a self-contained Skill. No server infrastructure. No authentication complexity. Just portable, version-controlled expertise that works everywhere (Claude.ai, Claude Code, and the API).

The advantages are real:

• ✅ Simpler setup (no server infrastructure)
• ✅ Self-contained (everything in one folder)
• ✅ More efficient context (progressive disclosure)
• ✅ Works everywhere (not just Claude Code)
• ✅ Easy to version control and share

Example: A “code review” Skill that runs git diff, uses grep to find patterns, and executes custom scripts - all self-contained. No server needed.

The MCP Reality Check

Let’s be honest about the GitHub MCP server example that gets thrown around a lot. Compare it to the gh CLI:

The GitHub CLI (gh) can:

• Create/edit/close issues and PRs
• Review PRs, add comments, approve/request changes
• Manage releases, workflows, secrets
• Search code, issues, PRs
• Authentication via gh auth login
• Output JSON with --json flag

The GitHub MCP server adds:

• Structured tool definitions
• Parsed responses (JSON)
• Slightly easier for Claude to use

But honestly? A Skill using gh CLI would be simpler, just as capable, more portable, self-contained, and easier to debug.

The GitHub MCP server is more about demonstrating MCP than solving a real problem.

When MCP Actually Matters

Don’t get me wrong - MCP isn’t useless. It genuinely adds value when:

1. No good CLI tool exists - Slack, Google Drive, many proprietary APIs
2. Real-time event handling needed - WebSockets, webhooks
3. Complex state management - Authenticated sessions, connection pools
4. Service has terrible CLI ergonomics - Some APIs are just painful to use from bash

Better MCP examples:

Slack MCP Server:

• No good CLI alternative
• Handles WebSocket connections for real-time events
• Maintains authentication state properly
• Manages rate limiting

Database MCP Server:

• Connection pooling
• Transaction management
• Better error handling for Claude
• (Though honestly, a Skill with psql works fine for many cases)

Google Drive MCP Server:

• No good CLI alternative
• OAuth flow is complex
• MCP handles this properly

The Hybrid Approach

The real power comes from using them together strategically:

MCP Server: Connects to GitHub API
Skill: Teaches Claude your code review standards

Together: Claude uses GitHub MCP to fetch PR data,
then applies your Skill's expertise to review it

Another example:

MCP Server: Connects to your database
Skill: Contains your SQL best practices and query patterns

Together: MCP provides access, Skill ensures queries
follow your organization's conventions

My Take

Here’s what I’ve learned: The MCP hype has led to servers being built for things that don’t need them. Many MCP servers are solving problems that good CLI tools already solve.

Better mental model:

• Skills + CLI = For most things (which is probably 80% of your use cases)
• MCP = For services without good CLI tools or complex API requirements
• Both together = When you need both access AND expertise

The Skills + CLI approach is underutilized. It’s simpler, more portable, and often the right choice. Before you spin up an MCP server, ask yourself: “Could I do this with a Skill and some bash/Python scripts?”

If the answer is yes, you probably should.

The Bigger Picture

Looking at the four concepts together:

Commands - Manual control when you want it Skills - Automatic expertise that follows you everywhere
Subagents - Task delegation with isolated contexts MCP - External system connectivity (when you really need it)

They’re complementary tools. But start simple. Start with Skills. Add MCP only when you genuinely need it.

The best engineers I know use the simplest tool that solves the problem. Not the most impressive one.

What About Agents?

Quick note on Subagents: They’re powerful for task specialization - code review, debugging, parallel work.

Use Subagents when you need:

• Isolated context (don’t pollute main conversation)
• Different tool permissions for different tasks
• Parallel execution

But again - start simple. A well-crafted Skill might be all you need.

Final Thoughts

The agentic coding space is moving fast. New tools emerge constantly. Marketing materials make everything sound essential.

But software craftsmanship is about knowing when to use the simple solution. Skills with command-line tools are often that simple solution. They’re portable, self-contained, and just work.

MCP has its place. But don’t let the hype drive your architecture decisions. Build what solves your actual problems, not what sounds impressive in blog posts.

I like to think of myself as a realistic optimist. These tools can make us more effective. But only if we use them thoughtfully.

Start with Skills. Add complexity only when you need it.

Now let’s get back to building something great.

References and Further Reading

If you want to dive deeper into this topic, here are the best resources I found:

Official Anthropic Documentation:

1. Skills explained: How Skills compares to prompts, Projects, MCP, and subagents - The authoritative comparison from Anthropic (Nov 13, 2025)
2. Extending Claude’s capabilities with skills and MCP servers - Official deep dive with real use cases (Dec 19, 2025)

Independent Analysis and Practical Guides:

3. Understanding Claude Code’s Full Stack: MCP, Skills, Subagents, and Hooks Explained - Excellent developer perspective covering the entire stack (Nov 9, 2025)
4. Claude Skills vs MCP: Better Together with Connect AI - Empirical testing with token usage measurements (Nov 11, 2025)
5. Beyond Deadwoodworks: How Claude Code Skills Super-charge MCP Servers - Practical workflow examples (Dec 15, 2025)

Technical Deep Dives:

6. Claude Skills vs. MCP: A Technical Comparison for AI Workflows - Comprehensive technical analysis (Oct 27, 2025)
7. Claude Skills vs. MCP: A Tale of Two AI Customization Philosophies - Architectural analysis (Oct 30, 2025)
8. Claude Skills vs MCP: The 2026 Guide to Agentic Architecture - Forward-looking perspective (Jan 2026)

Note: While these resources are excellent, most of them treat MCP as essential infrastructure without questioning whether simpler CLI-based Solutions might suffice. That’s the gap this post aims to fill - helping you think critically about which tool actually solves your problem.