🎯

create-slash-commands

🎯Skill

from cfircoo/claude-code-toolkit

What it does

Generates slash commands for Claude Code with XML-structured prompts and YAML configuration

📦

Part of

cfircoo/claude-code-toolkit(15 items)

create-slash-commands

Installation

git cloneClone repository

git clone https://github.com/cfircoo/claude-code-toolkit.git

Shell ScriptRun shell script

./install.sh

Shell ScriptRun shell script

./install.sh -i

Shell ScriptRun shell script

./install-mac.sh

Shell ScriptRun shell script

./install-linux.sh

+ 5 more commands

ConfigurationMCP configuration (may be incomplete)

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "h...

📖 Extracted from docs: cfircoo/claude-code-toolkit

Need more details? View full documentation on GitHub →

4Installs

AddedFeb 4, 2026

View on GitHub Back to Skills

Skill Details

SKILL.md

Expert guidance for creating Claude Code slash commands. Use when working with slash commands, creating custom commands, understanding command structure, or learning YAML configuration.

Overview

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 XML tags, YAML frontmatter, dynamic context loading, and intelligent argument handling.

Create .claude/commands/ directory (project) or use ~/.claude/commands/ (personal)
Create command-name.md file
Add YAML frontmatter (at minimum: description)
Write command prompt
Test with /command-name [args]

File: .claude/commands/optimize.md

```markdown

---

description: Analyze this code for performance issues and suggest optimizations

---

Analyze the performance of this code and suggest three specific optimizations:

```

Usage: /optimize

Claude receives the expanded prompt and analyzes the code in context.

All generated slash commands should use XML tags in the body (after YAML frontmatter) for clarity and consistency.

- What the command does and why it matters

```markdown

What needs to happen and why this matters.

Context about who uses this and what it accomplishes.

```

or - How to execute the command

```markdown

Sequential steps to accomplish the objective:

First step
Second step
Final step

```

- How to know the command succeeded

```markdown

Clear, measurable criteria for successful completion.

```

- When loading dynamic state or files

```markdown

Current state: ! git status

Relevant files: @ package.json

```

(Note: Remove the space after @ in actual usage)

- When producing artifacts that need checking

```markdown

Before completing, verify:

Specific test or check to perform
How to confirm it works

```

- When running tests is part of the workflow

```markdown

Run tests: ! npm test

Check linting: ! npm run lint

```

- When creating/modifying specific files

```markdown

Files created/modified:

./path/to/file.ext - Description

```

```markdown

---

name: example-command

description: Does something useful

argument-hint: [input]

---

Process $ARGUMENTS to accomplish [goal].

This helps [who] achieve [outcome].

Current state: ! relevant command

Files: @ relevant/files

Parse $ARGUMENTS
Execute operation
Verify results

Operation completed without errors
Output matches expected format

```

Simple commands (single operation, no artifacts):

Required: , ,
Example: /check-todos, /first-principles

Complex commands (multi-step, produces artifacts):

Required: , ,
Add: (if loading state), (if creating files), (what gets created)
Example: /commit, /create-prompt, /run-prompt

Commands with dynamic arguments:

Use $ARGUMENTS in or tags
Include argument-hint in frontmatter
Make it clear what the arguments are for

Commands that produce files:

Always include tag specifying what gets created
Always include tag with checks to perform

Commands that run tests/builds:

Include tag with specific commands
Include pass/fail criteria in

The skill should intelligently determine whether a slash command needs arguments.

User provides specific input:

/fix-issue [issue-number] - Needs issue number
/review-pr [pr-number] - Needs PR number
/optimize [file-path] - Needs file to optimize
/commit [type] - Needs commit type (optional)

Pattern: Task operates on user-specified data

Include argument-hint: [description] in frontmatter and reference $ARGUMENTS in the body.

Self-contained procedures:

/check-todos - Operates on known file (TO-DOS.md)
/first-principles - Operates on current conversation
/whats-next - Analyzes current context

Pattern: Task operates on implicit context (current conversation, known files, project state)

Omit argument-hint and don't reference $ARGUMENTS.

In tag:

```markdown

Fix issue #$ARGUMENTS following project conventions.

This ensures bugs are resolved systematically with proper testing.

```

In tag:

```markdown

Understand issue #$ARGUMENTS from issue tracker
Locate relevant code
Implement fix
Add tests

```

In tag:

```markdown

Issue details: @ issues/$ARGUMENTS.md

Related files: ! grep -r "TODO.*$ARGUMENTS" src/

```

(Note: Remove the space after the exclamation mark in actual usage)

For structured input, use $1, $2, $3:

```markdown

---

argument-hint:

---

Review PR #$1 with priority $2 and assign to $3.

```

Usage: /review-pr 456 high alice

Project commands: .claude/commands/

Shared with team via version control
Shows (project) in /help list

Personal commands: ~/.claude/commands/

Available across all your projects
Shows (user) in /help list

File naming: command-name.md → invoked as /command-name

Required - Describes what the command does

```yaml

description: Analyze this code for performance issues and suggest optimizations

```

Shown in the /help command list.

Optional - Restricts which tools Claude can use

```yaml

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

```

Formats:

Array: allowed-tools: [Read, Edit, Write]
Single tool: allowed-tools: SequentialThinking
Bash restrictions: allowed-tools: Bash(git add:*)

If omitted: All tools available

Command file: .claude/commands/fix-issue.md

```markdown

---

description: Fix issue following coding standards

---

Fix issue #$ARGUMENTS following our coding standards

```

Usage: /fix-issue 123 high-priority

Claude receives: "Fix issue #123 high-priority following our coding standards"

Command file: .claude/commands/review-pr.md

```markdown

---

description: Review PR with priority and assignee

---

Review PR #$1 with priority $2 and assign to $3

```

Usage: /review-pr 456 high alice

Claude receives: "Review PR #456 with priority high and assign to alice"

See [references/arguments.md](references/arguments.md) for advanced patterns.

Execute bash commands before the prompt using the exclamation mark prefix directly before backticks (no space between).

Note: Examples below show a space after the exclamation mark to prevent execution during skill loading. In actual slash commands, remove the space.

Example:

```markdown

---

description: Create a git commit

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

---

Context

Current git status: ! git status
Current git diff: ! git diff HEAD
Current branch: ! git branch --show-current
Recent commits: ! git log --oneline -10

Your task

Based on the above changes, create a single git commit.

```

The bash commands execute and their output is included in the expanded prompt.

Use @ prefix to reference specific files:

```markdown

---

description: Review implementation

---

Review the implementation in @ src/utils/helpers.js

```

(Note: Remove the space after @ in actual usage)

Claude can access the referenced file's contents.

1. Always use XML structure

```yaml

# All slash commands should have XML-structured bodies

```

After frontmatter, use XML tags:

- What and why (always)
- How to do it (always)
- Definition of done (always)
Additional tags as needed (see xml_structure section)

2. Clear descriptions

```yaml

# Good

description: Analyze this code for performance issues and suggest optimizations

# Bad

description: Optimize stuff

```

3. Use dynamic context for state-dependent tasks

```markdown

Current git status: ! git status

Files changed: ! git diff --name-only

```

4. Restrict tools when appropriate

```yaml

# For git commands - prevent running arbitrary bash

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

# For analysis - thinking only

allowed-tools: SequentialThinking

```

5. Use $ARGUMENTS for flexibility

```markdown

Find and fix issue #$ARGUMENTS

```

6. Reference relevant files

```markdown

Review @ package.json for dependencies

Analyze @ src/database/* for schema

```

(Note: Remove the space after @ in actual usage)

Simple analysis command:

```markdown

---

description: Review this code for security vulnerabilities

---

Review code for security vulnerabilities and suggest fixes.

Scan code for common vulnerabilities (XSS, SQL injection, etc.)
Identify specific issues with line numbers
Suggest remediation for each issue

All major vulnerability types checked
Specific issues identified with locations
Actionable fixes provided

```

Git workflow with context:

```markdown

---

description: Create a git commit

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

---

Create a git commit for current changes following repository conventions.

Current status: ! git status
Changes: ! git diff HEAD
Recent commits: ! git log --oneline -5

Review staged and unstaged changes
Stage relevant files
Write commit message following recent commit style
Create commit

All relevant changes staged
Commit message follows repository conventions
Commit created successfully

```

Parameterized command:

```markdown

---

description: Fix issue following coding standards

argument-hint: [issue-number]

---

Fix issue #$ARGUMENTS following project coding standards.

This ensures bugs are resolved systematically with proper testing.

Understand the issue described in ticket #$ARGUMENTS
Locate the relevant code in codebase
Implement a solution that addresses root cause
Add appropriate tests
Verify fix resolves the issue

Issue fully understood and addressed
Solution follows coding standards
Tests added and passing
No regressions introduced

```

File-specific command:

```markdown

---

description: Optimize code performance

argument-hint: [file-path]

---

Analyze performance of @ $ARGUMENTS and suggest specific optimizations.

This helps improve application performance through targeted improvements.

Review code in @ $ARGUMENTS for performance issues
Identify bottlenecks and inefficiencies
Suggest three specific optimizations with rationale
Estimate performance impact of each

Performance issues clearly identified
Three concrete optimizations suggested
Implementation guidance provided
Performance impact estimated

```

Usage: /optimize src/utils/helpers.js

See [references/patterns.md](references/patterns.md) for more examples.

Arguments reference: [references/arguments.md](references/arguments.md)

$ARGUMENTS variable
Positional arguments ($1, $2, $3)
Parsing strategies
Examples from official docs

Patterns reference: [references/patterns.md](references/patterns.md)

Git workflows
Code analysis
File operations
Security reviews
Examples from official docs

Tool restrictions: [references/tool-restrictions.md](references/tool-restrictions.md)

Bash command patterns
Security best practices
When to restrict tools
Examples from official docs

Analyze the user's request:

- What is the command's purpose?

- Does it need user input ($ARGUMENTS)?

- Does it produce files or artifacts?

- Does it require verification or testing?

- Is it simple (single-step) or complex (multi-step)?

Create frontmatter:

```yaml

---

name: command-name

description: Clear description of what it does

argument-hint: [input] # Only if arguments needed

allowed-tools: [...] # Only if tool restrictions needed

---

```

Create XML-structured body:

Always include:

- - What and why

- - How to do it (numbered steps)

- - Definition of done

Include when relevant:

- - Dynamic state (! commands) or file references (@ files)

- - Checks to perform if creating artifacts

- - Test commands if tests are part of workflow

- - Files created/modified

Integrate $ARGUMENTS properly:

- If user input needed: Add argument-hint and use $ARGUMENTS in tags

- If self-contained: Omit argument-hint and $ARGUMENTS

Apply intelligence:

- Simple commands: Keep it concise (objective + process + success criteria)

- Complex commands: Add context, verification, testing as needed

- Don't over-engineer simple commands

- Don't under-specify complex commands

Save the file:

- Project: .claude/commands/command-name.md

- Personal: ~/.claude/commands/command-name.md

A well-structured slash command meets these criteria:

YAML Frontmatter:

description field is clear and concise
argument-hint present if command accepts arguments
allowed-tools specified if tool restrictions needed

XML Structure:

All three required tags present: , ,
Conditional tags used appropriately based on complexity
No raw markdown headings in body
All XML tags properly closed

Arguments Handling:

$ARGUMENTS used when command operates on user-specified data
Positional arguments ($1, $2, etc.) used when structured input needed
No $ARGUMENTS reference for self-contained commands

Functionality:

Command expands correctly when invoked
Dynamic context loads properly (bash commands, file references)
Tool restrictions prevent unauthorized operations
Command accomplishes intended purpose reliably

Quality:

Clear, actionable instructions in tag
Measurable completion criteria in
Appropriate level of detail (not over-engineered for simple tasks)
Examples provided when beneficial

More from this repository10

🎯

sqlalchemy-postgres🎯Skill

sqlalchemy-postgres skill from cfircoo/claude-code-toolkit

🎯

generate-prd🎯Skill

Generates a comprehensive Product Requirements Document (PRD) by extracting key details from project context and creating a structured, professional specification.

🎯

pytest-best-practices🎯Skill

pytest-best-practices skill from cfircoo/claude-code-toolkit

🎯

debug-like-expert🎯Skill

Systematically investigates complex code issues using scientific method, gathering evidence and testing hypotheses to uncover root causes beyond surface-level symptoms.

🎯

ralph-orchestrator🎯Skill

ralph-orchestrator skill from cfircoo/claude-code-toolkit

🎯

damage-control🎯Skill

damage-control skill from cfircoo/claude-code-toolkit

🎯

create-meta-prompts🎯Skill

Generates structured, multi-stage Claude-to-Claude prompts with XML outputs, automated summarization, and provenance tracking for complex workflow pipelines.

🎯

create-hooks🎯Skill

Generates and configures Claude Code hooks to automate workflows, validate commands, and customize tool usage through event-driven shell or LLM-based triggers.

🎯

ralph-convert-prd🎯Skill

ralph-convert-prd skill from cfircoo/claude-code-toolkit

🎯

git🎯Skill

Performs safe Git operations like committing, pushing, and creating pull requests with built-in best practices and version control safeguards.