Claude Skills Might Be Bigger Than MCP (Here's Why You Should Care)

The Problem Every Claude User Faces

You’ve spent 30 minutes crafting the perfect prompt for Claude. You’ve fine-tuned the instructions, provided examples, set the tone just right. Claude generates exactly what you need - a perfectly formatted report following your company’s style guide.

The next day, you need another report. You start a new chat. Now you’re copying and pasting that prompt again. And again. And again.

Sound familiar?

This is the reality for most AI users today. We’ve got incredibly powerful models, but we’re stuck in a loop of repetitive prompting, context switching, and inconsistent outputs. Custom GPTs tried to solve this. Projects came close. But something was still missing.

Enter Claude Skills - released on October 16, 2025, and possibly the most significant update to how we interact with AI assistants.

As a CTO who uses Claude daily for everything from code reviews to architecture planning, I’ve spent the past two weeks diving deep into Skills. In this guide, I’ll break down what Skills actually are, how they differ from everything else, and why they might be the game-changer we’ve been waiting for.

What Are Claude Skills?

At its core, a Skill is deceptively simple: a folder containing a Markdown file with instructions, optionally accompanied by scripts and reference materials.

But here’s where it gets interesting.

Unlike traditional AI customization approaches that dump everything into the context window, Skills use something called progressive disclosure. Think of it like a well-organized library:

1. Claude starts by seeing just the name and description of each available skill (taking only a few dozen tokens each)

2. When you ask Claude to do something, it autonomously decides which skills are relevant

3. It then loads only the specific information it needs from those skills

4. Multiple skills can automatically stack together for complex workflows

Here’s a concrete example from Anthropic’s own implementation of a PDF Skill:

Claude knows a lot about PDFs—it can read them, extract text, analyze content. But it’s limited in its ability to manipulate PDFs directly (like filling out form fields). The PDF Skill gives Claude a pre-written Python script that can programmatically handle PDF forms. When you ask Claude to “fill out this form,” it:

1. Recognizes this is a PDF manipulation task

2. Loads the PDF Skill

3. Reads the instructions on how to use the form-filling script

4. Executes the script to complete the task

5. Never needs to load the PDF or script into its context window

This is fundamentally different from how we’ve been doing AI customization.

Why Progressive Disclosure Matters

Let me explain why this is such a big deal, especially for technical folks.

Traditional RAG (Retrieval-Augmented Generation) systems retrieve relevant chunks and stuff them into the context. This works, but it’s expensive and often imprecise. You’re constantly fighting context limits.

Skills flip this model. Instead of passive retrieval, Claude actively navigates a filesystem, deciding what to load based on the task. This means:

• Unbounded context: Skills can contain way more information than any context window because Claude only loads what it needs

• Efficiency: No wasted tokens on irrelevant information

• Composability: Multiple skills work together seamlessly

• Deterministic operations: Skills can include executable code for tasks where reliability matters more than generation

Here’s why this matters in practice: I can create a “Code Review Skill” that contains:

• My team’s entire coding standards document (50 pages)

• Linting rules and explanations

• Common anti-patterns to watch for

• Example good/bad code comparisons

• A Python script that runs static analysis

When I ask Claude to review code, it loads only the relevant sections. When it needs to run the linter, it executes the script without burning context tokens. And it all happens automatically.

The Great Comparison: Skills Vs Everything Else

This is where it gets interesting. Anthropic now has four different ways to customize Claude:

1. Custom Instructions (global behavior)

2. Projects (static knowledge bases)

3. MCP (external tool connections)

4. Skills (dynamic procedural knowledge)

Here’s how they actually differ:

Skills Vs Projects

Claude Projects are like giving Claude a detailed briefing at the start of a conversation. You upload documents (up to 200K tokens worth), set custom instructions, and every chat in that project has access to everything. (Learn more about Projects)

Skills are like training manuals Claude consults when needed. They:

• Activate dynamically based on the task

• Work everywhere (Claude.ai, Claude Code, API)

• Don’t consume context until triggered

• Stack with other skills automatically

Real-world example:

Project approach: I create a “Marketing Content” project, upload brand guidelines, past campaigns, customer personas. Every chat in this project sees all of it, whether I’m writing a tweet or a whitepaper.

Skills approach: I create separate skills for “Twitter Content,” “Blog Writing,” and “Email Campaigns.” Each contains specific guidelines. When I say “write a tweet,” only the Twitter skill loads. When I need a blog post, only the blog skill activates. Need both? They stack automatically.

The key difference: Projects are always-on context; Skills are on-demand expertise.

Skills Vs MCP (Model Context Protocol)

This is the comparison that confuses people most.

MCP connects Claude to external data sources and tools. It’s about access. Think: “Here’s your company’s database, Slack workspace, and GitHub repos.” (Learn more about MCP)

Skills teach Claude how to use those connections effectively. It’s about knowledge. Think: “Here’s how to query the database, format Slack messages according to team norms, and structure PR descriptions.”

They’re complementary, not competitive:

• MCP gives Claude the ability to fetch customer data from your CRM

• A Skill tells Claude how to analyze that data and format it into your company’s standard report template

• Another Skill might teach Claude your sales team’s specific workflow for following up

From a technical standpoint:

MCP is about the what (what tools are available)
Skills are about the how (how to use them properly)

You can use MCP without Skills (but Claude will need manual guidance)
You can use Skills without MCP (for self-contained workflows)
Using both together is where the magic happens

Skills Vs Custom Instructions

Custom Instructions are broad behavioral guidelines that apply to all your conversations: “Be concise,” “Assume I’m technical,” “Use Python for code examples.”

Skills are task-specific, activated only when relevant: “When creating PowerPoint presentations, use this specific design system and layout structure.”

The difference in token efficiency is massive. Custom instructions sit in every single message. Skills only load when you’re actually doing that specific task.

The Definitive Comparison Table

When to Use What: A Decision Framework

Here’s how I decide which tool to use:

Use Custom Instructions when:

• You want consistent behavior across all conversations

• The instruction is about how Claude communicates, not what it does

• Example: “Always show code examples in TypeScript and Python”

Use Projects when:

• You have a defined scope of work with static reference materials

• You want team members to collaborate in a shared context

• Example: “Product documentation project” with specs, user feedback, past features

Use MCP when:

• You need real-time data from external systems

• You want Claude to take actions in other tools

• Example: Connecting to your Notion workspace to read and update pages

Use Skills when:

• You have specialized workflows that require specific procedures

• You need executable code for deterministic operations

• You want automatic skill composition for complex tasks

• Example: “Financial modeling following our company’s DCF methodology”

Use combinations when:

• Complex workflows: MCP + Skills (data access + procedural knowledge)

• Team standardization: Projects + Skills (shared context + reusable procedures)

• Personal optimization: Custom Instructions + Skills (behavioral preferences + task expertise)

The Bigger Picture: What This Means

Skills represent a fundamental shift in how we think about AI customization.

Before Skills:

• One-shot interactions

• Heavy reliance on prompt engineering

• Inconsistent results

• Knowledge trapped in individual prompts

After Skills:

• Persistent, reusable expertise

• Procedural knowledge codified

• Consistent, repeatable workflows

• Knowledge that compounds over time

This is particularly important for:

Businesses: Can now encode institutional knowledge that persists beyond individual employees
Developers: Can create specialized AI agents without complex infrastructure
Teams: Can share and collaborate on AI workflows with version control
Individuals: Can build personal AI expertise that grows over their career

The Skills Mindset

The real power of Skills isn’t just in what they do - it’s in how they change your relationship with AI.

Before Skills: “Let me tell Claude what to do”
After Skills: “Let me teach Claude how I work”

This shift is subtle but profound. You’re not just getting help with tasks; you’re encoding your expertise in a way that compounds over time.

Every skill you create makes future work easier. Every refinement improves consistency. Every shared skill helps your team align.

This is the “second brain” concept applied to AI—not just storing information, but storing how you think and how you work.

The Coming “Skills Explosion”

Simon Willison (creator of Datasette) predicts a “Cambrian explosion” in Skills. Here’s why he’s probably right:

1. They’re model-agnostic: Skills are just Markdown files. They work with any LLM that can read files.

2. They’re shareable: GitHub repos of Skills are already appearing. Skill marketplaces will follow.

3. They’re portable: Same skill works in Claude.ai, Claude Code, Claude API, and potentially other models.

4. They’re simple: You don’t need to be a developer to create basic Skills.

5. They compound: Each skill you create makes future skills easier to build.

Anthropic’s GitHub repository already has example skills. The community is building more daily. Within six months, there will likely be thousands of open-source Skills for every domain imaginable.

What’s Next: Time to Build

Now that you understand what Skills are and how they differ from Projects, MCP, and Custom Instructions, you’re ready to start creating your own.

In Part 2 of this series - Getting Started with Claude Skills - The Complete Guide, we’ll get hands-on and cover:

• Creating Your First Skill: Step-by-step guide to building a production-ready Code Review Skill

• Adding Executable Scripts: How to include Python/JavaScript code for deterministic operations

• Real-World Use Cases: Actual Skills I’ve built as a CTO (architecture docs, sprint planning, technical interviews)

• Industry Examples: How companies like Rakuten, Box, and financial services firms are using Skills

• Advanced Patterns: Skill chains, conditional logic, and version management

• Common Pitfalls: Mistakes to avoid and how to debug Skills effectively

• Practical Tips: Lessons learned from two weeks of heavy usage

• Your Action Plan: Week-by-week roadmap to become a Skills expert

Understanding the theory is great. But the real power comes from building Skills that transform your daily workflow. In Part 2, we’ll turn this knowledge into action.

Want to enable Skills? Visit your Claude settings to get started. Skills are available for Pro, Max, Team, and Enterprise users.