Claude Code Slash Commands

This skill provides guidance for creating effective custom slash commands in Claude Code.

Quick Reference

Locations:

Project commands: .claude/commands/ (shared via git)
Personal commands: ~/.claude/commands/ (user-specific)

File format: Markdown (.md) with optional YAML frontmatter

Command name: Derived from filename (commit.md → /commit)

Frontmatter Options

See references/frontmatter.md for complete documentation.

Essential fields:

---
allowed-tools: Bash(git add:*), Bash(git commit:*)  # Tool permissions
description: Brief description shown in /help        # Required for model invocation
argument-hint: "[branch-name] [commit-type]"        # Shown in autocomplete
model: claude-haiku-4-5                             # Override session model
disable-model-invocation: true                      # Prevent auto-invocation
---

Dynamic Features

Arguments

All arguments: $ARGUMENTS captures everything after the command

Fix issue #$ARGUMENTS following our coding standards
# /fix-issue 123 high-priority → "123 high-priority"

Positional: $1, $2, $3... for specific arguments

Review PR #$1 with priority $2 and assign to $3
# /review-pr 456 high alice → $1="456", $2="high", $3="alice"

Bash Context Injection

Use ! prefix to execute bash and inject output as context:

## Context
- Current git status: !`git status`
- Current branch: !`git branch --show-current`
- Recent commits: !`git log --oneline -10`

Important: Requires allowed-tools with Bash tool in frontmatter.

File References

Use @ prefix to include file contents:

Review the implementation in @src/utils/helpers.js
Compare @src/old-version.js with @src/new-version.js

Command Patterns

See references/patterns.md for detailed patterns with full examples.

Pattern 1: Simple Task

For quick, focused operations:

---
description: Analyze code for performance issues
---

Analyze this code for performance issues and suggest optimizations.
Focus on: time complexity, memory usage, unnecessary operations.

Pattern 2: Git Workflow

For git operations with context:

---
allowed-tools: Bash(git add:*), Bash(git status:*), Bash(git commit:*)
description: Create a git commit
---

## Context
- Current git status: !`git status`
- Current git diff: !`git diff HEAD`
- Current branch: !`git branch --show-current`

## Your task
Based on the above changes, create a single commit with an appropriate message.

Pattern 3: Multi-Agent Orchestration

For complex tasks requiring parallel work:

---
allowed-tools: Bash(gh:*), TodoWrite
description: Find duplicate GitHub issues
---

Find duplicates for issue $ARGUMENTS.

Follow these steps precisely:
1. Use an agent to view the issue and return a summary
2. Launch 5 parallel agents to search for duplicates using diverse keywords
3. Feed results into another agent to filter false positives
4. Comment on the issue with up to 3 likely duplicates

Notes (tell your agents too):
- Use `gh` for GitHub interactions
- Do not use other tools beyond `gh`

Pattern 4: Structured Review

For comprehensive analysis workflows:

---
description: "Comprehensive code review"
argument-hint: "[review-aspects]"
allowed-tools: ["Bash", "Glob", "Grep", "Read", "Task"]
---

# Code Review

**Review Aspects (optional):** "$ARGUMENTS"

## Workflow:
1. **Determine Scope** - Check git status for changed files
2. **Run Reviews** - Execute applicable review agents
3. **Aggregate Results** - Summarize findings by severity
4. **Provide Action Plan** - Organize fixes by priority

Writing Guidelines

Use imperative language: "Create", "Execute", "Based on..."
Be explicit about constraints: Include what NOT to do
Specify output format: Provide templates for structured output
Enable multi-tool efficiency: Tell Claude it can use multiple tools in one response
Include a Notes section: For edge cases and important constraints

When to Use Slash Commands vs Skills vs Subagents

See references/decision-guide.md for detailed comparison.

Quick decision framework:

Use Case	Best Choice
Quick, repeatable task you trigger manually	Slash Command
Complex workflow with scripts/templates	Skill
Parallel execution with isolated context	Subagent
Team-shared workflow checked into git	Slash Command
Domain expertise Claude should auto-discover	Skill
Specialized role (security auditor, etc.)	Subagent

Key distinctions:

Commands: User-invoked (/command), simple prompts, manual trigger
Skills: Model-invoked (Claude decides), rich context, scripts/assets
Subagents: Own context window, parallel work, delegated tasks

Templates

Use templates in assets/templates/ as starting points:

simple-command.md - Basic single-purpose command
git-workflow.md - Git operations with context injection
multi-agent.md - Orchestration with parallel agents
review-command.md - Comprehensive review workflow

Best Practices from Anthropic

Granular tool permissions: Use wildcards for flexibility
```
allowed-tools: Bash(git add:*), Bash(git commit:*)
```
Context injection: Pre-load relevant state with bash execution
Clear task structure: Use ## Your task or ## Your Task section

Explicit constraints: Include prohibitions

Do not use any other tools or do anything else.
Do not send any other text or messages besides these tool calls.

Output format specification: Provide exact templates for structured output

Agent instructions: When using subagents, include notes they should follow

Notes (be sure to tell this to your agents, too):
- Use `gh` for GitHub interactions
- Make a todo list first

slash-commands