What Are MCP Skills? A Guide to Claude's Model Context Protocol

If you've been following AI development tools, you've probably heard about MCP — the Model Context Protocol. But the terminology can be confusing. What's the difference between MCP servers and MCP skills? How do they work together? And which ones should you install first?

This guide explains the MCP ecosystem clearly and shows you how to extend your AI coding assistant with real capabilities.

Understanding MCP: The Model Context Protocol

MCP (Model Context Protocol) is an open protocol developed by Anthropic that standardizes how AI assistants connect to external tools, data sources, and services. Before MCP, every AI tool had its own proprietary way of adding integrations. MCP creates a universal standard — similar to how USB standardized device connections.

MCP is now supported natively by Cursor, Windsurf, Claude Desktop, and a growing number of AI tools.

What MCP Enables

Without MCP, your AI assistant can only work with what you paste into the chat or what it can see in your open files. With MCP, the AI can:

• Read and query databases directly (PostgreSQL, MySQL, SQLite)
• Interact with APIs (GitHub, Slack, Jira, Linear)
• Access file systems beyond the current project
• Run commands in controlled environments
• Fetch live web data for research

MCP Servers vs. MCP Skills: What's the Difference?

This is the most common point of confusion. They're related but distinct concepts:

MCP Servers

An MCP server is a running process that exposes tools and data to your AI assistant via the MCP protocol. Think of it as a backend service. When you "install an MCP server," you're configuring your AI tool to connect to that server process.

Examples of MCP servers:

• A GitHub server that lets the AI create PRs, review code, and manage issues
• A PostgreSQL server that lets the AI query your database directly
• A Filesystem server that gives the AI read/write access to specific directories

Browse available servers in our MCP Servers Directory.

MCP Skills (AI Agent Skills)

An MCP skill (or AI agent skill) is a reusable workflow package — a set of instructions that teach your AI assistant how to perform a multi-step task. Skills are typically stored as SKILL.md files and combine context, instructions, and tool usage patterns into a repeatable workflow.

Examples of skills:

• A code review skill that reads a PR diff, checks for common issues, and writes structured feedback
• A deployment skill that runs tests, builds the project, and deploys to staging
• A documentation skill that reads source code and generates API documentation

Browse available skills in our AI Skills Directory.

How They Work Together

MCP servers provide capabilities (tools the AI can use). Skills provide workflows (how the AI should use those tools to accomplish a task). A skill might require one or more MCP servers to work:

Skill: "Code Review Workflow"
  └── Requires: GitHub MCP Server (to read PR diffs)
  └── Requires: Filesystem MCP Server (to check local code)
  └── Instructions: "Read the diff → check for issues → write review"

How MCP Servers Work Under the Hood

When you configure an MCP server in your AI tool, here's what happens:

1. Your AI tool starts the MCP server process (usually a Node.js or Python script)
2. The server announces its available tools to the AI via the MCP protocol
3. When the AI needs a tool, it sends a structured request to the server
4. The server executes the action and returns results to the AI
5. The AI incorporates the results into its response

Example: Using a GitHub MCP Server

Without GitHub MCP:

You: "What's in my latest PR?" AI: "I don't have access to your GitHub account. You'd need to paste the PR details here."

With GitHub MCP:

You: "What's in my latest PR?" AI: "PR #47 'Add user authentication' has 3 files changed: auth.ts (+85), middleware.ts (+12), login.tsx (+134). The tests pass. Here's a summary of the changes..."

The AI can directly access GitHub because the MCP server handles authentication and API calls.

How to Install MCP Servers

In Cursor

1. Open Settings → MCP
2. Click Add MCP Server
3. Paste the server configuration (name, command, and any required environment variables)
4. Cursor starts the server automatically

In Claude Desktop

1. Open your claude_desktop_config.json file (location depends on your OS)
2. Add the server entry to the mcpServers section:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your-token-here"
      }
    }
  }
}

3. Restart Claude Desktop

In Windsurf

1. Open Settings → MCP Configuration
2. Add the server configuration in JSON format
3. Restart Windsurf

Each MCP server in our directory includes ready-to-paste configuration for all supported tools.

How to Install AI Agent Skills

Skills are simpler to install since they're just files:

1. Find a skill — Browse our Skills Directory
2. Download the SKILL.md file — Click the download button or copy the content
3. Place it in your project — Add to .cursor/skills/ (Cursor) or .codex/skills/ (Codex CLI)
4. Reference it in your workflow — The AI reads the skill file when you invoke the relevant task

Skills don't require any server processes or configuration changes — they're just instruction files that teach the AI how to approach specific tasks.

Essential MCP Servers to Install First

If you're new to MCP, start with these high-impact servers:

1. Filesystem Server

Gives the AI controlled access to read and write files beyond the current project. Useful for cross-project operations.

2. GitHub Server

Lets the AI interact with your repositories — create PRs, review code, manage issues, and check CI status.

3. Database Server (PostgreSQL/SQLite)

Lets the AI query your database directly. Extremely useful for debugging data issues and writing queries.

4. Web Search/Fetch Server

Gives the AI the ability to search the web or fetch documentation pages. Useful for researching APIs and checking current information.

Browse all available servers in our MCP directory.

Writing Your Own Skills

Skills follow a straightforward markdown structure. Here's a realistic example of a code review skill:

# Code Review Skill

## Overview
Perform a structured code review on staged changes or a PR diff.

## Workflow
1. Read the diff (staged changes or PR)
2. Check each file for:
   - Type safety issues
   - Missing error handling
   - Security concerns (hardcoded secrets, SQL injection)
   - Performance anti-patterns
   - Naming convention violations
3. Group findings by severity (critical, warning, suggestion)
4. Write a structured review with file-level comments

## Output Format
For each finding:
- File and line number
- Severity level
- Description of the issue
- Suggested fix with code example

## Rules
- Don't flag style-only issues if a linter handles them
- Focus on logic errors and security issues first
- Be constructive — explain why something is a problem

The key to good skills is being specific about the workflow steps and output format. Vague instructions produce vague results.

For more on writing effective AI instructions, see our prompt engineering guide.

Security Considerations

MCP servers and skills can be powerful, which means you should take security seriously:

For MCP Servers

• Review permissions before installing — a GitHub MCP server needs your token, which grants access to your repositories
• Use minimal-scope API keys — create tokens with only the permissions the server needs
• Don't grant write access unless necessary — read-only access is safer for experimentation
• Only install servers from trusted sources — review the source code on GitHub before adding unknown servers

For Skills

• Read the SKILL.md before using it — understand what the skill instructs the AI to do
• Be cautious with skills that modify files or run commands — understand the scope of changes
• Test skills on non-critical projects first — verify behavior before using in production

MCP vs. Traditional Plugins and Extensions

You might wonder how MCP compares to traditional IDE extensions or API integrations:

Feature	MCP	IDE Extensions	Direct API Integration
Setup	JSON config	Install from marketplace	Write code
AI-native	✅ Yes	❌ No	❌ No
Cross-tool	✅ Works across AI tools	❌ Tool-specific	❌ App-specific
Maintenance	Community-maintained	Vendor-maintained	You maintain
AI reasoning	AI decides when to use tools	Manual trigger	Manual trigger

The key advantage of MCP is that it's AI-native — the AI decides when and how to use tools based on context, rather than requiring you to manually trigger actions.

Conclusion

MCP is transforming AI coding assistants from sophisticated autocomplete tools into genuine development partners that can interact with your entire toolchain. Start by installing a few essential MCP servers (GitHub, filesystem, database), explore the skills directory for pre-built workflows, and gradually expand your setup as you discover new use cases.

The ecosystem is growing rapidly — new servers and skills are published every week. Bookmark our MCP directory and skills directory to stay up to date.

---

Ready to get started? Browse our MCP Servers Directory for installable servers or the Skills Directory for reusable workflows. Need help with your prompts? Try our free Prompt Grader.