Skills, slash commands, sub-agents and MCP: your operational copilot

Skills, slash commands, sub-agents, and MCP servers are the four legs that turn a classic boilerplate into an operational copilot. If you've never used them, it sounds like jargon. The moment you wire them into your flow, you don't want to go back.

This guide explains what they are, when to use each, and how to fit them into your boilerplate.

Slash commands: the shortcut

A slash command is a reusable instruction you invoke with /. You define it once in .claude/skills/ and you can launch it as many times as you want.

Example: /verify

# Verify project quality

Run all linters and the build:

1. Run `bun lint:all`
2. Run `bun run build`
3. Report any errors found

When you type /verify, the agent runs exactly those steps. No need to remember them.

When to create one: when you notice you repeat the same instructions 3+ times across sessions. That's the moment.

Skills: longer instructions

A skill is like a slash command but with more body: a full guide for a recurring task. For example:

• /new-feature → scaffolds a new feature following the pattern
• /release → closes a version, writes changelog, tags
• /session → documents session work in your system

Difference vs a simple slash command: skills usually have multiple steps, conditional branches, and references to other files.

Sub-agents: specialists

A sub-agent is an agent with its own instructions and a specific role. It lives in .claude/agents/ and is invoked with @:

@architecture-auditor review this PR
@quality-checker verify nothing breaks
@code-reviewer give me a second pair of eyes

Each has clean context (doesn't carry the whole conversation) and a specialized prompt. For tasks like auditing architecture or reviewing code, they produce better results than the general agent.

When to use them: review, validation, exhaustive search. Any task that benefits from "fresh eyes" without conversation noise.

MCP servers: connection to the real world

MCP (Model Context Protocol) is the standard for an agent to access external services.

The most useful in a boilerplate:

• Context7: live docs for libraries. Ask it for Next.js's current API and it brings it back without making things up.
• GitHub: read issues, open PRs, comment.
• Linear / Jira: read and create tasks.
• Discord / Slack: post updates to the team.
• Extended filesystem: access outside the project when needed.

Configuring one is 3 lines in ~/.claude/mcp.json. Suddenly the agent stops making up APIs because it can query the real ones.

How the four fit together

A well-orchestrated flow:

1. You type /new-feature blog-comments
2. The skill starts, asks clarifications, scaffolds the structure
3. The skill calls @architecture-auditor to validate
4. The skill queries Context7 MCP to see the latest API to use
5. The skill opens a PR via the GitHub MCP

You haven't typed anything after the initial prompt.

Common mistakes

1. Creating skills too early: if you've only done a task once, it's not a skill. Wait for the pattern.

2. Sub-agent that duplicates the main one: if it does the same thing, it adds nothing. The sub-agent must have a distinct prompt and clear role.

3. Undocumented MCPs: your agent knows there's a @github MCP, but not what you use it for in this project. Add a note in CLAUDE.md.

4. Slash commands with absolute paths: if the command uses /Users/..., it won't work on another machine. Use relative paths.

Bottom line

Skills, slash commands, sub-agents, and MCP aren't loose features. They're the tools that turn a repo into a copilot.

If your boilerplate ships them configured and documented, opening it is plugging in a car with a starter. If not, you're pushing it uphill.

The difference shows from the first session.