Claude Code Skills vs Slash Commands: What's the Difference and When to Use Each

Two Tools, One Goal: Automating Repetitive Work in Claude Code

Anyone who uses Claude Code for more than a few days notices the same pattern: you keep typing the same instructions, running the same setup steps, and re-explaining the same context. Claude Code gives you two distinct ways to fix this — slash commands and skills — and most users don’t have a clear picture of how they differ or which one to reach for.

This article breaks down both approaches. You’ll learn what slash commands and Claude Code skills actually are, how each one works under the hood, and the practical situations where one beats the other. Whether you’re building solo or setting up workflows for a team, getting this distinction right saves real time.

---

What Slash Commands Are in Claude Code

Slash commands are text-based shortcuts that inject pre-written instructions into your Claude Code session. Type / in the terminal, and Claude Code shows you a list of available commands. Some are built in. Others you create yourself.

Built-in slash commands

Claude Code ships with a set of native slash commands that handle session management and common developer tasks:

• /help — lists available commands and usage
• /clear — resets the conversation context
• /compact — summarizes the conversation to save context window space
• /cost — shows how many tokens the current session has consumed
• /doctor — runs a health check on your Claude Code setup
• /model — switches the active model mid-session
• /memory — edits your CLAUDE.md project memory file

These are useful, but the more interesting category is custom slash commands.

Custom slash commands

You can create your own slash commands by dropping markdown files into specific directories:

• Project-level commands go in .claude/commands/ inside your project folder. They’re available to anyone working on that project.
• User-level commands go in ~/.claude/commands/ in your home directory. They follow you across every project.

Each file becomes a command. A file named review.md becomes /project:review or /user:review depending on where it lives.

Inside the file, you write a prompt template. Claude treats the file’s content as instructions when you invoke the command. You can also include a $ARGUMENTS placeholder to pass dynamic input at runtime — so /project:review src/auth.ts would replace $ARGUMENTS with src/auth.ts in your prompt.

Here’s a simple example. A file at .claude/commands/test-coverage.md might contain:

Analyze the test coverage for $ARGUMENTS. 
Identify which branches are untested, suggest specific test cases, 
and flag any logic that's particularly risky to leave uncovered.

Invoke it with /project:test-coverage src/payments/ and Claude runs that analysis on the payments directory.

Slash commands are text-in, text-out. They shape what Claude does by controlling the prompt. They don’t give Claude any new capabilities — they just make existing prompts reusable and shareable.

---

What Skills Are in Claude Code

Skills are a different category. Instead of prompt templates, skills are programmatic tools that extend what Claude can actually do. They give Claude access to functions, APIs, and external services it wouldn’t otherwise reach.

How skills work technically

Claude Code supports tool use through two main mechanisms: direct function definitions and MCP (Model Context Protocol) server integrations.

When a skill is registered, Claude knows it can call that tool by name, with specific inputs, and get back a structured result. Claude reasons about when to use a tool based on what it’s trying to accomplish. That’s different from slash commands, where you explicitly invoke a specific action.

Skills run code. A skill might:

• Search the web and return structured results
• Send an email through an SMTP service
• Query a database and return rows
• Generate an image using a diffusion model
• Post to Slack, update a Jira ticket, or push a file to S3

MCP servers as a skill delivery mechanism

Model Context Protocol is Anthropic’s open standard for connecting AI models to external tools. An MCP server exposes a set of tools that Claude Code can call. Once you configure an MCP server in your ~/.claude/mcp.json or project-level config, those tools become available in your session.

This is where skills get powerful. Instead of writing a prompt that says “please check if this code has security vulnerabilities,” you could give Claude a skill that actually calls a static analysis API and returns real findings.

The tradeoff: skills require more setup. You either need to configure an existing MCP server or build one. That’s more work than dropping a markdown file in a directory.

---

The Core Difference

Here’s the clearest way to frame it:

	Slash Commands	Skills
What they are	Prompt templates	Callable functions/tools
How Claude uses them	You invoke them explicitly	Claude invokes them autonomously when relevant
Setup complexity	Low — write a markdown file	Higher — configure or build a tool/MCP server
What they can do	Shape Claude’s reasoning and output	Execute real actions in external systems
Input	Text arguments	Typed parameters
Output	Text response	Structured data + text
Sharing	Commit .claude/commands/ to a repo	Share MCP server config or npm package
Best for	Reusable instructions and workflows	Real-world integrations and actions

Slash commands are about how Claude thinks. Skills are about what Claude can touch.

---

When to Use Slash Commands

Slash commands are the right choice when your main problem is prompt repetition — you keep giving Claude the same context or instructions, and you want a faster way to trigger that behavior.

Situations where slash commands shine

Standardizing code review. If you always want Claude to check for the same things — security, performance, test coverage, naming conventions — a slash command captures that checklist once and makes it instantly reusable.

Onboarding context. New team members can run /project:setup and get a full explanation of the codebase conventions, common gotchas, and where to start. No one needs to write it out again.

Repeated debugging workflows. When you’re in a debugging session and keep asking Claude to trace a specific kind of error, a slash command standardizes the approach so you don’t have to re-explain it every time.

Documentation templates. /project:document-function can instruct Claude to generate JSDoc comments in a specific format, with specific sections, every time — without you specifying the format manually.

Team consistency. Committing .claude/commands/ to your repo means everyone on the team uses the same prompts for the same tasks. Less drift, fewer inconsistencies.

The key signal: if your problem is “I keep writing similar prompts,” slash commands solve it. They’re low friction, easy to maintain, and require no infrastructure.

---

When to Use Skills

Skills are the right choice when you need Claude to do something beyond reasoning and text generation — when it needs to interact with external systems, trigger real actions, or work with structured data from outside sources.

Situations where skills are essential

Sending notifications or emails. A slash command can tell Claude how you want email drafts formatted. A skill can actually send the email.

Running API calls. If Claude needs to check the status of a deployment, query your database, or pull live data from an external service, that requires a tool — not a prompt template.

Generating assets. Image generation, video creation, and other media tasks need a callable capability that routes to the right model and returns the result.

Chaining multi-step workflows. When Claude needs to search for something, process the results, then take action based on what it finds, you need skills at each step — not just better prompts.

Interacting with your infrastructure. Skills can wrap CLI tools, call Docker APIs, run test suites, or trigger CI/CD pipelines. Prompt templates can describe those things, but they can’t execute them.

The key signal: if your problem is “Claude can’t reach what it needs to work with,” skills solve it. They extend Claude’s reach from text to action.

---

How to Build Each One

Building a custom slash command

1. Decide whether the command is project-specific (.claude/commands/) or personal (~/.claude/commands/)
2. Create a markdown file with a descriptive name (e.g., audit-deps.md)
3. Write the prompt inside the file. Be specific about what you want Claude to do, what format to use, and any constraints.
4. Include $ARGUMENTS where you want dynamic input to be inserted
5. Save the file and test it in Claude Code with the appropriate prefix (/project:audit-deps or /user:audit-deps)

Tips:

• Keep each command focused on one task
• Add a comment at the top of the file describing when to use it — future you will appreciate it
• Commit project commands to source control so the whole team benefits

Building or integrating skills

The options here depend on how much you want to build:

Option 1: Use an existing MCP server. There are pre-built MCP servers for web search, file systems, databases, and more. Configure them in your ~/.claude/mcp.json and they become available immediately.

Option 2: Build a custom MCP server. If you need tools specific to your workflow, you can write a small Node.js or Python server that implements the MCP protocol. Anthropic’s documentation covers the spec in detail.

Option 3: Use a pre-packaged skills library. This is where a tool like MindStudio’s Agent Skills Plugin comes in, which the next section covers.

---

Where MindStudio Fits In

If you’re building out Claude Code skills and don’t want to write and maintain individual MCP servers from scratch, MindStudio’s Agent Skills Plugin (@mindstudio-ai/agent) is worth knowing about.

It’s an npm SDK designed specifically for agentic coding environments like Claude Code. Install it in your project and it exposes 120+ typed capabilities as simple method calls:

agent.sendEmail()
agent.generateImage()
agent.searchGoogle()
agent.runWorkflow()
agent.postToSlack()

Each method handles the infrastructure layer — rate limiting, retries, authentication — so Claude can focus on reasoning about when to use a capability, not how to wire it up.

The practical benefit: you get a broad set of production-ready skills without building and maintaining separate MCP servers for every integration. If Claude Code needs to search the web, generate an image, send a notification, and log results to a spreadsheet in a single workflow, those four capabilities come from one SDK rather than four separate integrations.

For teams already using MindStudio’s visual no-code platform to build AI agents, this creates a clean bridge: the same workflows running in the platform can be triggered directly from Claude Code sessions using agent.runWorkflow(). That’s useful when you’ve already built a complex, tested workflow in MindStudio and want Claude Code to invoke it as a step in something larger.

You can try MindStudio free at mindstudio.ai.

---

Combining Both in Practice

The most effective Claude Code setups use both — slash commands for prompting consistency and skills for real-world reach. They’re not competing approaches; they solve different halves of the same problem.

A practical example: imagine you’re building a code review workflow.

• A slash command (/project:review) captures your standard code review checklist and format
• A skill (searchGoogle or a custom linting tool) lets Claude pull in current vulnerability data or run automated checks
• Another skill (postToSlack) lets Claude send the review summary to your team’s channel

The slash command controls how Claude thinks about the review. The skills control what Claude can access and affect during it.

When you’re setting up a workflow and asking yourself “is this a slash command or a skill?”, the question to ask is: does this need to do something, or does it need to instruct something? Action → skill. Instruction → slash command.

---

Frequently Asked Questions

What’s the difference between a slash command and a CLAUDE.md file?

Both influence how Claude behaves, but in different ways. CLAUDE.md is persistent project memory — it’s always in context, always shaping Claude’s understanding of your project. Slash commands are on-demand — you invoke them when you need a specific prompt template run. Think of CLAUDE.md as permanent background context and slash commands as reusable foreground actions.

Can slash commands trigger external actions?

Not directly. Slash commands are prompt templates. They can instruct Claude to describe an action or format output in a way that’s useful for triggering something else, but they don’t execute code or call APIs. If you need actual execution, you need a skill or MCP tool.

Do I need to know how to code to use skills?

For basic MCP server setup (configuring existing servers), not really — it’s mostly JSON configuration. For building custom tools or using an SDK like MindStudio’s Agent Skills Plugin, you’ll need basic JavaScript or Python knowledge. Slash commands require no coding at all.

Are slash commands shared between projects?

Project-level commands (.claude/commands/) are scoped to that project directory. If you commit the folder to your repo, anyone who clones it gets the commands too. User-level commands (~/.claude/commands/) are personal and available across all your projects on that machine.

How does Claude decide when to use a skill?

Claude uses tools autonomously based on what it’s trying to accomplish. If you ask it to “search for recent security advisories related to this package,” and it has a web search skill available, it’ll use it. You don’t have to explicitly invoke skills the way you do slash commands — Claude reasons about which tools are relevant to the task at hand.

Can I use slash commands and skills together in the same session?

Yes, and this is often the best approach. You might invoke a slash command to set the format and criteria for an analysis, while Claude autonomously uses skills to pull in the data it needs to run that analysis. The two mechanisms are complementary.

---

Key Takeaways

• Slash commands are prompt templates — they make reusable instructions you invoke explicitly with /command-name
• Skills are callable tools — they extend Claude’s reach into external systems, APIs, and real-world actions
• Use slash commands when you’re solving prompt repetition: standardizing reviews, documenting conventions, or sharing workflows with a team
• Use skills when Claude needs to act: send messages, call APIs, generate assets, or interact with your infrastructure
• Combine both for the most capable workflows — slash commands control how Claude reasons; skills control what Claude can touch
• MindStudio’s Agent Skills Plugin provides 120+ pre-built skills as typed method calls, so you can extend Claude Code without building individual MCP servers from scratch

If you’re looking to build out a more capable Claude Code setup — or want a visual platform for creating the broader AI workflows that those skills can plug into — MindStudio is worth exploring.