Claude Code Skills and Slash Commands: The Complete Guide

Claude Code skills and slash commands are reusable instruction sets that let you automate repetitive tasks with a single forward slash. Instead of re-explaining the same workflow every time, you create a skill file once and call it with /skill-name. The result: consistent output, optimized token usage, and workflows that take 20 minutes instead of 2 hours.

I run a growth agency with a small team. We made a decision early: no massive headcount. Instead, we invested in making each person 10x more productive through AI automation. This is the same approach driving massive revenue growth for SaaS companies—doing more with less. Claude Code skills are how we do it. This article breaks down exactly how we use them—including real examples from our team training sessions.

What Are Claude Code Skills?

A Claude Code skill is a set of instructions saved in a SKILL.md file that tells Claude exactly how to complete a specific task. Think of it as an SOP for AI. You write it once, save it in your .claude/skills/ folder, and invoke it anytime with a slash command.

Every skill file has two parts:

1. YAML frontmatter - Metadata that tells Claude when to use the skill
2. Markdown instructions - The actual steps Claude follows

Here's the basic structure:

---
name: proposal-generator
description: Generate customized client proposals from call transcripts and email threads
version: 1.0.0
---

# Proposal Generator Skill

[Your detailed instructions here]

The name becomes your slash command. Save this as proposal-generator/SKILL.md in your .claude/skills/ folder, and you can now type /proposal-generator to invoke it.

Key insight: Skills stored in ~/.claude/skills/ work globally across all projects. Skills stored in a specific project folder only work in that project. For most use cases, global skills are more practical.

Skills vs Slash Commands: What's the Difference?

This confuses a lot of people. Here's the simple breakdown:

Slash commands are what you type manually. You're in control.

Skills can also be invoked by Claude automatically when the task matches the skill's description. This makes them more powerful for complex, multi-step workflows where Claude needs to decide which tools to use.

In practice, most people use them interchangeably. The important thing is having reusable instruction sets instead of re-prompting from scratch every time.

Why Context Window Optimization Matters

Here's something most people miss about Claude Code: the terminal version is significantly better than the desktop app for serious work.

Why? Context windows.

When you use the Claude desktop app, you stay in one continuous conversation. Every message, every response, every back-and-forth—it all accumulates. Eventually:

• The app starts lagging
• Claude starts forgetting earlier context
• You hit token limits
• Quality degrades

Claude Code in the terminal solves this. You can spin up a new instance with Command + N, invoke a skill, get your output saved to a file, close that session, and start fresh. The next skill only reads the output file—not the entire conversation history.

This is the unlock. You're not wasting brain power (tokens) on irrelevant context. Each task gets a clean slate with only the information it needs.

Example workflow:

1. /research skill → Creates research.md with findings
2. Close terminal, open new one
3. /write-script skill → Reads research.md, creates script.md
4. Close terminal, open new one
5. /linkedin-posts skill → Reads script.md, creates 3 LinkedIn posts

Each step uses a fresh context window. Each skill only loads what it needs. No token waste. No lag. No forgotten context.

How to Create a Skill File (Step-by-Step)

Let me walk you through creating a skill file from scratch, using a real example: a proposal generator.

Step 1: Enable Hidden Files

Your .claude folder is hidden by default. On Mac, press Command + Shift + . in Finder to show hidden files. Or ask Claude Code to show you where it is.

Step 2: Navigate to Your Skills Folder

cd ~/.claude/skills/

If the skills folder doesn't exist, create it:

mkdir -p ~/.claude/skills/

Step 3: Create Your Skill Directory

mkdir proposal-generator

Step 4: Create the SKILL.md File

Open Claude Code and put it in plan mode first (Shift + Tab). This is critical. Plan mode makes Claude ask clarifying questions instead of rushing to execute.

Then prompt:

Help me create a skill file to send proposals to potential clients.
My goal is to make proposals feel customized and personalized.
Typically we use context from:
- Call transcripts
- Email threads
- My own input

I also want a step where you use the prospect's domain to do
deep research and find gaps we didn't uncover.

Claude will ask clarifying questions:

• What format should the proposal be in?
• What sections should it include?
• What tools should it use for research?

Answer these, and Claude creates your skill file.

Step 5: Edit the Output Path

One thing people miss: tell your skill where to save outputs. Add a line like:

## Output Location
Save all proposals to: /Users/[username]/claude-code-projects/proposals/

This keeps you organized and makes it easy for other skills to reference the output.

Step 6: Test It

Open a new terminal, type claude, then /proposal-generator. If it works, you're done. If not, iterate on the instructions.

Real Workflow Examples

Example 1: Client Proposal Generation

We built two connected skills:

Skill 1: /proposal

• Takes call transcript + email thread as input
• Uses Exa to research the prospect's company
• Outputs a structured markdown proposal with: executive summary, understanding of their needs, proposed solution, scope of work, timeline, investment, why us

Skill 2: /proposal-pdf

• Reads the markdown proposal
• Converts it to a branded PDF using our colors and fonts
• Saves to the proposals folder

Total time: 15 minutes instead of 2 hours. And the quality is consistent every time.

Example 2: Content Repurposing Pipeline

This is how I create a week's worth of content from one research session:

Skill 1: /youtube-research

• Takes a topic as input
• Uses Serper to search for what's ranking
• Analyzes top 3 competing articles
• Gathers stats and data points
• Outputs a comprehensive research.md

Skill 2: /youtube-script

• Reads research.md
• Creates a full video script with hooks, sections, and CTAs
• Saves as script.md

Skill 3: /seo-article

• Reads research.md
• Creates a 2000+ word blog post optimized for search
• Includes FAQ section, tables, schema markup
• Saves as seo-article.md

Skill 4: /linkedin-posts

• Reads script.md
• Creates 3 LinkedIn posts with different angles: story-based hook, contrarian hook, practical/personal hook
• Saves as linkedin-posts.md

From one 30-minute research session, I get: 1 YouTube script, 1 SEO blog post, 3 LinkedIn posts. All saved, all ready to use. (If you want to see what makes LinkedIn outreach actually work, check out our complete LinkedIn outbound strategy guide.)

Example 3: Spam Checking and Campaign QA

For our outbound campaigns, we have:

/spintax-check

• Takes campaign copy as input
• Validates spintax syntax
• Checks for common errors
• Suggests improvements

/spam-check

• Analyzes copy for spam trigger words
• Scores deliverability risk
• Suggests alternatives for flagged phrases

These save hours of manual review across multiple campaigns. Getting deliverability right matters—here's why most cold emails get ignored and what to do about it.

The Divide and Conquer Method

This is the most important concept in this entire article.

Don't try to do everything in one skill.

When you create a research report, you're feeding Claude tons of raw input: call transcripts, email threads, website content, competitor analysis. That burns through your context window fast.

But here's the thing: your copywriting skill doesn't need all that noise. It just needs the cleaned-up research output.

So you divide and conquer:

1. Research skill - Handles all the raw input, outputs a clean summary
2. Copywriting skill - Only reads the clean summary, outputs copy
3. Campaign skill - Only reads the copy, pushes to your tools

Each skill gets a fresh context window. Each skill only loads what it needs. You're not wasting tokens on irrelevant information.

The co-founder of Anthropic talks about this. He says he can't leave his house without having five things operating at the same time. That's the mindset. Multiple parallel workflows, each optimized for its specific task.

Best Practices

Always Use Plan Mode

Develop this muscle: Shift + Tab before every complex task.

Plan mode makes Claude ask questions instead of rushing to execute. You get better output because Claude understands exactly what you want before starting.

The founder of Claude Code says he never starts anything without plan mode. Neither should you.

Create a Profile.md

Save a PROFILE.md in your .claude folder with:

• Who you are
• What you do
• Your expertise
• Your voice and tone
• Stories and anecdotes you want referenced

Then tell your skills to read this file. Now every output is personalized to you without re-explaining yourself.

Store MCP Servers in Your .claude Folder

MCP servers are just JSON files. Save them in your .claude folder and they work globally. You set it up once, reference it in your skills, and never think about it again.

Add to Favorites

Drag your .claude folder to your Finder favorites. Same with your claude-code-projects folder. Quick access makes everything faster.

Name Skills Clearly

Use kebab-case: proposal-generator, spam-checker, youtube-research. The name becomes your slash command, so make it memorable.

Frequently Asked Questions

Key Takeaways

• Skills are SOPs for AI. Write instructions once, invoke with a slash command forever.
• Terminal beats desktop app. Fresh context windows mean better output and no lag.
• Divide and conquer. Use multiple focused skills instead of one massive skill. Each gets a clean context window.
• Always use plan mode. Shift + Tab before complex tasks. Claude asks questions instead of guessing.
• Create a Profile.md. Personalize every output without re-explaining yourself.
• Store skills globally. Save in ~/.claude/skills/ to use across all projects.
• Name skills clearly. The name becomes your slash command.

Start Small, Build Up

You don't need to build 20 skills on day one. Start with one task you do repeatedly. Maybe it's writing proposals. Maybe it's checking campaigns for spam. Maybe it's generating LinkedIn posts.

Create one skill. Test it. Iterate. Then build the next one.

Over time, you'll have a library of skills that compound your output. Tasks that used to take hours happen in minutes. And you can share skills with your team—upload them to a GitHub repo and everyone benefits.

This is how small teams compete with big ones. Not by hiring more people, but by making each person dramatically more effective. Combine skills with tools like Clay for data enrichment and you've got an outbound machine that runs on autopilot.