Objective

Create effective slash commands for Claude Code that enable users to trigger reusable prompts with /command-name syntax. Slash commands expand as prompts in the current conversation, allowing teams to standardize workflows and operations. This skill teaches you to structure commands with YAML frontmatter, dynamic context loading using ! and @ syntax, and intelligent argument handling.

Quick Start

Workflow

1. Create .claude/commands/ directory in project (for portability)
2. Create command-name.md file
3. Add YAML frontmatter (at minimum: description)
4. Write 1-2 line instruction (no sections)
5. Test with /command-name [args]

Note: Use ~/.claude/commands/ (personal) only if specifically requested for global availability.

Pattern Selection

For comprehensive XML/Markdown decision guidelines, see:

• XML/Markdown Decision Framework

Ultra-Minimalist Pattern

File: .claude/commands/optimize.md

---
description: Optimize code performance
---

Optimize the code for better performance

Basic Pattern

File: .claude/commands/review-code.md

---
description: Review code quality
---

## Objective

Review the code for quality issues and improvements.

## Process

1. **Read the code** - Understand the implementation
2. **Identify issues** - Find bugs, inefficiencies, and improvements
3. **Suggest improvements** - Provide actionable recommendations

## Success Criteria

- Code quality assessment provided
- Specific issues identified
- Actionable recommendations given

Command Types

1. Ultra-Minimalist (1 line)

Pattern: Single-line instruction, no sections

Best for: Direct skill invocation

---
description: Debug this code
---

Load the engineering skill to debug this code

2. Structured Pattern (sections)

Pattern: Objective, Process, Success Criteria

Best for: Multi-step workflows

---
description: Create a test plan
---

## Objective

Create a comprehensive test plan for the feature.

## Process

1. **Analyze requirements** - Understand what needs testing
2. **Identify test cases** - List all scenarios
3. **Prioritize tests** - Focus on critical paths

## Success Criteria

- Test plan covers all requirements
- Critical paths identified
- Test cases are actionable

3. Advanced Pattern (with context)

Pattern: Structured + dynamic context

Best for: Commands that need file/git context

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

## Context

Current git status: ! `git status`

## Objective

Create a well-structured git commit.

## Process

1. **Review changes** - Understand what was modified
2. **Write message** - Follow conventional commits format
3. **Execute commit** - Stage and commit changes

## Success Criteria

- Commit follows conventional format
- Message is clear and descriptive
- All changes properly staged

Templates Index

Structure Templates

Simple Command

---
description: [Clear, actionable description]
---

[Single instruction or Objective + Process + Success Criteria]

Advanced Command

---
description: [Description]
argument-hint: [input] # If needed
allowed-tools: [restrictions] # If needed
---

## Objective

[What and why]

## Process

1. [Step 1]
2. [Step 2]
3. [Step 3]

## Success Criteria

- [Criterion 1]
- [Criterion 2]

Create New Command

Workflow

1. Determine pattern:

   • Ultra-minimalist for direct skill invocation
   • Structured for multi-step workflows
   • Advanced for context-dependent commands

2. Create file:

   • Default: .claude/commands/command-name.md
   • Alternative: ~/.claude/commands/command-name.md (only if specifically requested)

3. Write content:

   • Ultra-minimalist: Single instruction
   • Structured: Objective + Process + Success Criteria

4. Test: Run /command-name to verify it works

Pattern Selection Guidelines

Use Ultra-Minimalist when:

• Command directly loads and invokes a skill
• Single, clear instruction is sufficient
• No complex workflow needed

Use Structured when:

• Multi-step process required
• Clear success criteria needed
• Some complexity involved

Use Advanced when:

• Dynamic context needed (files, git, etc.)
• Tool restrictions required
• Complex workflows with verification

Create New Command (Advanced)

Complex Command Creation

For commands that need routing or complex logic:

1. Assess complexity:

   • Is simple structure sufficient?
   • Does AI need to make routing decisions?
   • Are there multiple pathways?

2. Choose approach:

   • Simple structure: Use basic pattern
   • Skill routing: Delegate to appropriate skill
   • Command routing: Use XML tags for complex logic

3. Create file:

   • Follow patterns in references/common-patterns.md
   • Use appropriate YAML frontmatter
   • Test thoroughly

4. Optimize:

   • Remove unnecessary complexity
   • Ensure clear instructions
   • Verify success criteria

Edit Existing Command

Common Edits

Update description:

---
description: Updated description with better trigger words
---

Add arguments:

---
description: Review code for issues
argument-hint: [file-or-directory]
---

Review $1 for code quality, standards compliance, and potential improvements.

Add tool restrictions:

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

Create a git commit following our standards.

Audit Existing Command

Quality Checklist

Structure:

• Clear, actionable description
• Appropriate pattern (minimalist vs structured)
• Proper YAML frontmatter
• Useful success criteria

Content:

• Instructions are clear and actionable
• Success criteria are measurable
• No unnecessary complexity
• Appropriate level of detail

Functionality:

• Command executes correctly
• Arguments work as expected
• Dynamic context loads properly
• Tool restrictions are appropriate

Comprehensive Documentation

For complete command patterns, examples, and best practices, see:

• Common Patterns
• Command Structure Standards