---
title: "Claude Skills: Give Claude Superpowers (MCP Servers Explained)"
description: "MCP servers let Claude connect to your tools, databases, and APIs. Here's how to install, use, and build them—without the jargon."
pillar: "Claude Code"
level: "intermediate"
date: "2026-01-20"
url: "https://theglitch.ai/academy/claude-code/claude-skills-guide"
---

# Claude Skills: Give Claude Superpowers (MCP Servers Explained)

MCP servers let Claude connect to your tools, databases, and APIs. Here's how to install, use, and build them—without the jargon.


# Claude Skills: Give Claude Superpowers

By the end of this guide, you'll understand what MCP servers ("Claude Skills") are, how to install them, and how they make Claude dramatically more useful.

> **The Glitch's Take:** "Out of the box, Claude can think. With skills, Claude can do. That's the difference between an assistant and an operator."

---

## Who This Is For

- You use Claude regularly and want more capabilities
- You've heard about MCP but don't understand it
- You want Claude to work with your actual tools (Notion, GitHub, databases)

## Who This Is NOT For

- Complete AI beginners (start with [Start Here](/academy/fundamentals/ai-start-here) first)
- You're looking for a technical MCP development guide

---

## TL;DR

- **MCP servers** = plugins that let Claude interact with external tools
- **Common skills:** file access, web browsing, database queries, API calls
- **Installation:** Drop a config file in the right place
- **Security:** Skills only access what you explicitly allow
- **Best ones to start:** File system, web fetch, memory

---

## What Are Claude Skills?

Claude Skills (technically called "MCP servers") are plugins that give Claude new abilities.

| Without Skills | With Skills |
|----------------|-------------|
| Claude can discuss your files | Claude can read/write your actual files |
| Claude can describe APIs | Claude can call APIs directly |
| Claude can explain databases | Claude can query your database |
| Claude can talk about Notion | Claude can read/edit your Notion pages |

Think of it like this: base Claude is a brain. Skills give it hands.

---

## How They Work (Simple Version)

1. You install a skill (a small program that runs on your computer)
2. You tell Claude it can use that skill
3. Claude uses the skill when relevant

Example: With the "file system" skill installed, you can say:
- "Read my project's README file"
- "Create a new file called notes.txt"
- "Find all JavaScript files in my project"

Claude actually does it, not just tells you how.

---

## The Best Skills to Start With

### 1. File System Access

**What it does:** Read, write, and search files on your computer

**Install via Claude Desktop config:**
```json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/directory"]
    }
  }
}
```

**Use cases:**
- Read project files without copy-pasting
- Create and edit files directly
- Search through codebases

### 2. Web Fetch

**What it does:** Fetch and read web pages

**Why you want it:** Claude can read documentation, check current information, pull in reference material.

### 3. Memory / Notes

**What it does:** Persistent memory across conversations

**Why you want it:** Claude remembers context, preferences, and project details between sessions.

### 4. GitHub

**What it does:** Interact with GitHub repos, issues, PRs

**Use cases:**
- Create issues from conversation
- Check PR status
- Browse repo structure

### 5. Database (PostgreSQL, SQLite)

**What it does:** Query and modify databases

**Use cases:**
- Debug data issues
- Write and test queries
- Explore database structure

---

## How to Install a Skill

### Step 1: Find Your Config File

**Mac:** `~/Library/Application Support/Claude/claude_desktop_config.json`
**Windows:** `%APPDATA%\Claude\claude_desktop_config.json`

If it doesn't exist, create it.

### Step 2: Add the Skill

```json
{
  "mcpServers": {
    "skill-name": {
      "command": "npx",
      "args": ["-y", "@package/name", "arguments"]
    }
  }
}
```

### Step 3: Restart Claude Desktop

The skill loads on startup.

### Step 4: Verify It Works

Ask Claude: "What tools do you have access to?"

It should list the skill.

---

## Example: Full Setup for Developers

Here's a practical config for software development:

```json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/projects"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your-github-token"
      }
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}
```

This gives Claude:
- Access to your projects folder
- GitHub integration
- Persistent memory

---

## Security: What Skills Can Access

Skills only access what you explicitly configure.

| Good Practice | Bad Practice |
|---------------|--------------|
| Allow `/Users/name/projects` | Allow `/` (entire disk) |
| Use read-only when possible | Give write access by default |
| Use scoped API tokens | Use admin/root tokens |
| Audit skill permissions | Install skills blindly |

### The Permission Model

When Claude wants to use a skill, you'll see what it's about to do. You approve or deny.

Example:
```
Claude wants to: Read file /projects/app/package.json
[Allow] [Deny] [Allow for this session]
```

You stay in control.

---

## Agent Skills vs MCP Skills

Two different things with similar names:

| Type | What It Is | Where It Lives |
|------|------------|----------------|
| **MCP Skills** | Plugins that connect Claude to external tools | Claude Desktop config |
| **Agent Skills** | Markdown files with reusable context | Your file system |

MCP Skills give Claude abilities (read files, call APIs). Agent Skills give Claude knowledge (your style, your processes, your standards).

Both are useful. This section covers Agent Skills—the markdown ones you create yourself.

---

## Agent Skills: Reusable Context

Agent skills are markdown files that Claude reads when relevant. Write once, use everywhere.

**Examples:**
- Email reply skill (your greeting, your signature, your tone)
- Code review skill (your standards, your checklist)
- Post generation skill (your voice, your format)
- PR review skill (your team's conventions)

**The unlock:** No more copy-pasting your preferences into every conversation.

### Skill Scope Options

| Scope | Location | When to Use |
|-------|----------|-------------|
| **Personal** | `~/.claude/skills/` | Your personal workflows |
| **Project** | `/project/.claude/skills/` | Team shares this skill |
| **Enterprise** | Managed by org | Company-wide standards |

---

## Creating Your First Agent Skill

### Minimum Viable Skill

```markdown
# Name: Email Reply

## Description
Compose professional email responses with consistent greeting and signature.

## Instructions
When replying to emails:
1. Start with "Hey [Name], thanks for reaching out"
2. Keep tone friendly but professional
3. End with signature:

   Best,
   [Your Name]
   [Your Role]
```

That's it. A skill can be this simple.

### Email Reply Example

**User types:** "Reply to this email: [paste email]"

**Claude uses skill to:**
- Auto-greet appropriately
- Maintain your tone
- Add your signature
- Fill in the actual response

**Time saved:** 30 seconds vs 5 minutes per email.

### Advanced Skill Structure

For more complex skills:

```
/skills/
└── email-reply/
    ├── skill.md           # Main instructions
    ├── docs/
    │   └── tone-guide.md  # Reference materials
    └── scripts/
        └── send-email.sh  # Executable actions
```

**Advanced features:**
- `docs/` folder — Reference materials Claude can read
- `scripts/` folder — Actions Claude can execute
- `allowed_tools` — Restrict what tools the skill can use
- `model` — Specify which model to use

---

## The Skill Generator (Meta)

The most useful skill is one that creates other skills.

**How it works:**
1. Install Anthropic's skill-generator skill
2. Ask Claude: "Create a skill for [task]"
3. Claude asks questions (role, tone, preferences)
4. Generates a custom skill for you

**Example prompt:**
> "Help me generate a skill to quickly answer support emails"

Claude asks:
- What's your role?
- What tone do you use?
- Any standard phrases?
- What should the signature look like?

Then generates a skill tailored to you.

**Where to find it:** [Anthropic's skills examples repo](https://github.com/anthropics/anthropic-cookbook)

---

## Skills vs CLAUDE.md

| Use Case | Tool |
|----------|------|
| Project-specific context | CLAUDE.md |
| Cross-project automation | Agent Skill |
| One-time instructions | Chat prompt |
| Reusable patterns | Agent Skill |

**Example:**
- CLAUDE.md: "This Next.js project uses App Router, TypeScript strict mode"
- Agent Skill: "Review all PRs with these code standards"

CLAUDE.md is for THIS project. Skills are for ALL projects.

---

## Scripts in Skills

Skills can execute actions, not just provide context.

```markdown
# Name: Auto Email Sender

## Description
Draft and send email via API

## Script
scripts/send-email.sh
```

**Use cases:**
- Send email after drafting
- Post to Slack after generating message
- Update database after analysis
- Trigger webhook after completion

**Power + risk:** Skills with scripts can take actions. Review carefully before using.

---

## Building Your Own MCP Skills (Overview)

If you want Claude to connect to a tool that doesn't have an existing MCP skill, you can build one.

**What you need:**
- Basic programming knowledge (Python or TypeScript)
- Understanding of the tool's API
- MCP SDK

**Basic structure:**
1. Define what operations the skill supports
2. Implement handlers for each operation
3. Package and install

**Time investment:** 2-4 hours for a simple skill, 1-2 days for complex ones.

Detailed guide: [Anthropic MCP Documentation](https://docs.anthropic.com/en/docs/mcp)

---

## Common Issues

| Problem | Cause | Fix |
|---------|-------|-----|
| Skill not showing up | Config syntax error | Validate JSON, check for typos |
| "Permission denied" | Path not in allowed list | Update config to include path |
| Skill crashes | Missing dependency | Check npm install ran correctly |
| "Cannot connect" | API token wrong | Verify token is correct and has right permissions |

---

## FAQ

### Do skills work with Claude.ai web?

Currently, MCP servers work with Claude Desktop app. Web support may come later.

### Are skills safe?

Skills only do what you configure them to do. Review permissions before installing third-party skills.

### Do skills cost extra?

No. They're part of your Claude subscription.

### Can I use multiple skills?

Yes. Add multiple entries to your `mcpServers` config.

### What happens if a skill has a bug?

Claude will see an error and report it. Skills can't access anything outside their configured permissions.

### Where do I find more skills?

- [Anthropic MCP Servers](https://github.com/modelcontextprotocol/servers) — Official
- [MCP Hub](https://mcp.run) — Community collection

---

## What's Next

**If you want deeper file system integration:**
- [Context Layers](/academy/claude-code/context-layers) — Make Claude understand your project

**If you want to automate workflows:**
- [Build Your First Agent](/academy/agents/build-first-agent)

**If you want to build custom skills:**
- [Anthropic MCP Documentation](https://docs.anthropic.com/en/docs/mcp)

---

*Last verified: 2026-01-20*