Claude Skills and Slash Commands

If you’ve used Claude Code for more than a few sessions, you’ve probably noticed the / prompt — slash commands. These deceptively simple shortcuts are one of the most powerful productivity features in the entire Claude ecosystem. Combined with Claude Skills (custom slash commands you define yourself), they transform Claude Code from a capable tool into a personalized automation engine tuned to your exact workflow.

This guide covers everything you need to know about Claude Skills and slash commands: what they are, which built-in commands matter most, and how to build your own custom commands that save you hours every week.

Updated May 14, 2026: xAI now ships a Skills-compatible coding agent: Grok Build CLI reads AGENTS.md and Anthropic-format Skills out of the box (May 2026 beta).

What Are Slash Commands in Claude?

Slash commands are shortcuts that trigger specific behaviors or workflows in Claude Code. Type a forward slash (/) in the input field and you’ll see a menu of available commands. Selecting one executes a predefined action — either a built-in Claude Code behavior or a custom workflow you’ve defined.

The concept will feel familiar if you’ve used Slack (where /giphy inserts a GIF) or Discord (where /poll creates a poll). Slash commands in Claude Code work the same way — they’re shorthand for complex instructions. Instead of typing “review my code for security vulnerabilities and list them in order of severity,” you type /security-review and Claude knows exactly what to do.

For context on how this fits into the broader Claude toolset, the Claude Code beginners guide is the right starting point before going deep on commands.

Built-In Slash Commands You Should Know

Claude Code ships with a set of built-in slash commands. Here are the most useful ones for everyday work:

/help

Displays a full list of available slash commands, including any custom ones you’ve created. Always the first command to run in a new Claude Code install.

/clear

Clears the current conversation context. Useful when you’ve finished one task and want to start fresh without the previous conversation influencing Claude’s responses. Keeps your API costs down too — a clean context means fewer tokens.

/compact

Compresses the current conversation into a dense summary while preserving the key context. Use this when a session has been running long and you want to continue without losing important context but also without bloating the token count further.

/review

Triggers a code review of the files Claude has been working on. Claude will look for bugs, security issues, performance problems, and style inconsistencies — and produce a structured report.

/cost

Shows the API cost incurred in the current session. An essential command for keeping track of spending, especially during long or complex tasks.

/init

Reads your project and generates a CLAUDE.md file with suggested context and instructions. Great for setting up a new project — run it once and you have a solid starting configuration to customize.

What Are Claude Skills?

Claude Skills are custom slash commands that you create yourself. They’re stored as Markdown files in a special .claude/commands/ directory within your project (or globally at ~/.claude/commands/ for commands available across all projects). Each skill file defines what Claude should do when that command is triggered.

Anatomy of an Effective Skill File

A skill is a markdown file with a YAML frontmatter block that controls its name and autocomplete description. The file body is injected as a system-level instruction whenever you invoke the skill. Here is a complete example for generating PostgreSQL migration scripts:

---
name: db-migration
description: Generate a safe, reversible PostgreSQL migration
---

You are writing a PostgreSQL migration. Every migration must:
1. Open with BEGIN; and close with COMMIT;
2. Include a -- UP section and an exact -- DOWN reversal
3. Use CREATE INDEX CONCURRENTLY to avoid table locks
4. Use IF EXISTS / IF NOT EXISTS guards on all DDL
5. Never add a NOT NULL column without backfilling existing rows first

Output a single .sql file. No explanatory prose — only SQL and inline comments.

The structure that makes this effective: a clear persona statement (“you are writing…”), explicit rules Claude wouldn’t infer from context alone, and a precise output format requirement. The more specific the rules, the more consistently the skill performs across different sessions and team members.

Global vs. project skills: Skills in ~/.claude/skills/ are available in every project — good for cross-project utilities like commit messages or code review. Skills in .claude/skills/ inside a repo are project-scoped — ideal for encoding your team’s naming conventions, API patterns, or internal deployment steps. When names collide, project-level skills take precedence over global ones, so you can maintain a generic global baseline and override it per project.

Skills are powerful because they encode your personal workflows into reusable commands. Things you do repeatedly — code reviews, deployment checklists, writing specific types of documents, running test suites — can all be turned into one-word commands.

How to Create Your First Claude Skill

Creating a skill is straightforward. Here’s exactly how to do it:

• In your project folder, create a directory called .claude/commands/
• Inside that directory, create a new Markdown file. The filename becomes the slash command name. For example, deploy-check.md creates the command /deploy-check.
• Write the instructions inside the Markdown file. These are the instructions Claude will follow every time you run that command.
• Save the file. The command is immediately available in your Claude Code session — no restart needed.

Here’s a simple example. A file called changelog.md might contain:

“Look at all git commits since the last version tag. Write a structured changelog entry in the format: ## Version X.X.X [date]. Include sections for New Features, Bug Fixes, and Breaking Changes. Only include commits that represent user-visible changes.”

Now every time you run /changelog, Claude follows these exact instructions without you needing to type them out again.

Advanced Skill Features

Passing Arguments to Skills

Skills can accept arguments, making them flexible rather than rigid. Use the placeholder $ARGUMENTS in your skill file and Claude will incorporate whatever you pass after the command name.

For example, a feature-spec.md skill containing “Write a detailed technical specification for the following feature: $ARGUMENTS. Include: user stories, data model changes, API endpoints, and acceptance criteria.” can be invoked as:

/feature-spec user notification system

Claude fills in $ARGUMENTS with “user notification system” and produces a full technical spec.

Including File Context in Skills

Skill files can reference other files in your project using a special include syntax. This is useful for skills that always need to know about a specific configuration file, design system, or set of standards. Claude reads the referenced files automatically when the skill is invoked.

Global vs. Project Skills

Skills stored in ~/.claude/commands/ (your home directory) are available in every Claude Code project. Skills stored in .claude/commands/ within a specific project are only available in that project. Use global skills for general-purpose workflows and project skills for project-specific procedures.

Practical Skill Ideas to Get You Started

Here are some skill ideas that work well for common development and business workflows:

Eight High-Value Skills to Build This Week

1. /commit — Generates a Conventional Commits-format message from the staged diff. Include a rule that the subject line must be under 72 characters with a mandatory scope. Saves 2–3 minutes per commit and creates a consistent git history.
2. /pr-description — Writes a pull request description from the branch diff. Include template sections: Summary, Changes Made, Testing Notes, Breaking Changes. Wire to the GitHub MCP server to post automatically.
3. /test — Generates unit tests in your project’s framework and assertion style. Specify whether to mock external calls, how to name test files, and where fixtures live. Without explicit instructions Claude generates tests that don’t match your project style.
4. /explain — Detailed technical explanation of a code block for inserting as a comment or doc entry. Include an instruction to explain the “why” behind decisions, not just the “what.”
5. /sec-review — Security review against a fixed checklist: SQL injection, XSS, CSRF, insecure direct object reference, hardcoded secrets, dependency vulnerabilities. Claude works through the list methodically.
6. /api-design — Reviews or generates a REST/GraphQL API surface using your team’s conventions on versioning, error format, pagination, and auth headers.
7. /refactor — Guides a safe refactor in small verifiable steps: identify smells, propose a plan, execute incrementally, verify no behavior change after each step.
8. /standup — Reads recent git commits and open PRs via GitHub MCP and drafts a standup update in your team’s format. Runs in under 30 seconds.

Start with /commit and /test — highest frequency of use, clearest ROI. Add the others as you identify prompts you type more than once a week.

• /daily-standup — Reviews recent git commits and generates a standup summary (“what I did yesterday, what I’m doing today, any blockers”).
• /pr-description — Reads the current branch’s changes and writes a pull request description with context, testing notes, and risk assessment.
• /refactor $ARGUMENTS — Takes a function or file name and refactors it for readability and performance while preserving behavior.
• /test-coverage — Runs the test suite, identifies untested code paths, and writes tests to fill the gaps.
• /blog-post $ARGUMENTS — Takes a topic and writes a structured first draft for a technical blog post.
• /onboarding-doc — Reads your project and generates an onboarding guide for new team members.

Skills in the Claude Desktop App

The slash command system is primarily associated with Claude Code (the terminal tool), but elements of it also appear in the Claude Desktop App. In the Desktop App, you can use slash commands to switch modes, access project context, and trigger certain built-in behaviors. Custom skills defined in your Claude Code installation are not automatically available in the Desktop App — they’re separate systems.

Skills in Claude Desktop: Document and Workflow Automation

While skills are most commonly discussed in the context of Claude Code, they work identically in Claude Desktop — same file format, same invocation syntax, same autocomplete. The difference is in which skills deliver the most value per interface. Claude Desktop users tend to work with documents, reports, and research rather than code, so the highest-ROI skills are document-focused.

A /meeting-notes skill structures raw meeting notes into a consistent format: attendees, decisions made, action items with owners, and a next-meeting agenda. Define the format once in the skill file; every set of meeting notes you process comes out in the same structure, ready to paste into Notion or email. A /research-brief skill formats competitive research into a fixed template — market size, key players, differentiators, risks — so every brief your team produces is instantly comparable. A /weekly-summary skill takes a dump of your weekly activity and produces a concise executive summary in the exact format your manager expects.

Because skill files live in ~/.claude/skills/, they are available in both Claude Desktop and Claude Code without any duplication. Define a skill once, use it everywhere across both interfaces and all your projects.

Connecting Skills to Scheduled Tasks

One of the most powerful uses of Claude Skills is combining them with Claude’s scheduling capabilities. You can configure Claude to run a specific skill on a schedule — for example, running /daily-standup every morning at 9am, or /test-coverage every night before deployment.

Composing and Parameterizing Skills

Skills become significantly more powerful when you compose them. A /feature skill can instruct Claude to: (1) invoke /api-design to finalize the endpoint contract, (2) invoke /test to generate a test scaffold, (3) implement the feature, (4) invoke /pr-description to write the PR body. This creates a repeatable, documented development workflow that every engineer on the team runs identically — no individual interpretation of “how we do features here.”

You can also parameterize skills with inline context at invocation time: /test for the PaymentService class, use fixtures from tests/fixtures/payments.json. The skill provides the framework and style rules; the inline text supplies the specifics. This keeps skills reusable across different files without needing one skill file per class or module.

Skills also work inside scheduled tasks. A nightly agent can invoke /sec-review on every file changed in the last 24 hours, writing results to a shared report. Because the skill encodes your exact security checklist, every nightly run applies the same criteria — no criteria drift between who ran the review last Tuesday versus this Tuesday. Consistent, auditable, zero-effort.

This combination of skills and scheduling is covered in detail in our guide on Claude Scheduled Tasks. The combination unlocks a level of automation where Claude is genuinely working for you around the clock, not just when you’re at the keyboard.

10 Claude Skills Plays Most Users Have Not Tried

You have built a Skill or two. The 10 plays below produce dramatically more leverage from Skills and slash commands in 2026.

1. Skill versioning in a Git repo

Treat Skills as code. Version them in a Git repo with PR-style review. Skill quality compounds across iterations; rollbacks are trivial when a tweak makes things worse.

2. Composable Skills that call other Skills

One Skill can reference another. Build a small library of atomic Skills (tone-check, fact-pass, accessibility-audit) and compose them in higher-level Skills (publish-ready-article).

3. Skills tied to slash commands for muscle-memory speed

/edit, /research, /brief, /critique. Each fires a specific Skill. Your most-used workflows become two keystrokes instead of explanation paragraphs.

4. Team Skills shared via .claude/skills folder

Team Skills live in a shared .claude/skills/ folder in your repo. Anyone on the team has the same agent capabilities the moment they pull main. Institutional knowledge becomes versioned and shared.

5. Negotiation Skill encoded from Voss

The Never Split the Difference playbook as a Skill. Apply to every tough conversation: rent negotiation, vendor pushback, customer save, salary review. Quality of hard conversations compounds.

6. Critique-mode Skills for honest feedback

Default Claude is too agreeable. A Critique Skill instructs Claude to push back hard, surface weaknesses, play devil advocate. Feedback quality jumps; your work improves faster.

7. Privacy-aware Skills for sensitive workflows

For workflows that touch sensitive data (legal review, financial analysis, HR drafts), build Skills that enforce privacy constraints: no PII passed externally, no claims made without source, no recommendations beyond drafting.

8. Onboarding Skill for new team members

Encode your onboarding playbook as a Skill. New hires get consistent guided onboarding in YOUR org voice instead of relying on whoever is around that week.

9. Quarterly Skill audit

Skills drift as workflows evolve. Quarterly review: which Skills get used (keep and refine), which never (delete), which are missing (add). Skill library stays sharp.

10. Skill marketplace participation

Publish your best non-proprietary Skills to the community. Contribute and consume. The Skills ecosystem compounds when participants share.

Best Practices for Writing Great Skills

A skill is only as good as its instructions. Here’s what separates excellent skills from mediocre ones:

• Be specific about the output format. Tell Claude exactly what format you want — bullet points, JSON, a specific heading structure, etc.
• Include the “why.” Explaining why you need something done a certain way helps Claude make better judgment calls at the edges.
• Define what to do when things are uncertain. A good skill anticipates edge cases: “If you can’t find X, ask me before proceeding.”
• Keep skills focused. One skill should do one thing well. If you need to do A then B, create two skills and chain them rather than one complicated skill.
• Version your skills. Treat your .claude/commands/ directory like any other code — commit it to git so you can track changes and roll back if a skill starts producing worse results after an edit.

A Resource for Better AI Prompting

Writing good skills is really about writing good prompts — a skill you can develop systematically. Get the free Beginners in AI newsletter for daily Claude Skills, slash-command patterns, and prompt templates you can directly adapt into your own Skills library. Or for a 1-on-1 walkthrough of designing Skills tuned to your workflow, book a Claude Crash Course ($75).

Frequently Asked Questions

Are slash commands available in all Claude interfaces?

Built-in slash commands are available in Claude Code (the terminal tool) and partially in the Claude Desktop App. The claude.ai web interface has a limited version of slash commands for switching modes. Custom skills (user-defined slash commands) are a Claude Code feature and are not available in the Desktop App or web interface.

How many custom skills can I create?

There’s no documented limit on the number of custom skills you can create. Practically speaking, having too many skills makes the command menu unwieldy. Most users find that 10–20 well-crafted skills cover 80% of their repetitive tasks. Focus on quality over quantity — a few excellent skills beat dozens of mediocre ones.

Can I share my skills with my team?

Yes. Skills stored in your project’s .claude/commands/ directory are committed to your project’s git repository. When teammates clone or pull the repository, they get the same skills. This makes it easy to standardize workflows across a development team — everyone uses the same /pr-description format, for example.

What’s the difference between a skill and a CLAUDE.md instruction?

CLAUDE.md contains persistent background context and rules that apply to every Claude Code session in that project. Skills are on-demand commands you trigger explicitly. Use CLAUDE.md for things Claude should always know (coding standards, project architecture). Use skills for things you want to trigger at specific moments (generate a changelog, run a security audit).

Can skills trigger other skills?

Not directly through a built-in chaining mechanism, but you can write a skill that instructs Claude to sequentially perform multiple named tasks. Claude will carry out the steps in order. True command chaining (where one slash command automatically triggers another) is not a built-in feature, but the behavior can be approximated through carefully written skill instructions.

For more on automating complex workflows with Claude, read our guide on best AI tools for beginners.

Sources

• Grokipedia: Claude
• Anthropic Official Documentation

You May Also Like

• How to Use Claude AI
• Best Claude Prompts
• Claude AI Login
• ChatGPT vs Claude vs Gemini
• Claude Code Beginners Guide
• Claude Usage Limits: How They Work and How to Stretch Them Further
• Skills vs Connectors vs Plugins: How to Extend Claude
• How to Build Presentations with Claude

Related Posts

• AI agents for beginners: 5 boring tasks you can automate this week (no code)