A comprehensive system for generating production-ready Claude Code slash commands through a simple question-based workflow.

Overview

This skill helps you create custom slash commands for Claude Code by:

Asking 5-7 straightforward questions about your command needs
Generating complete command .md files with proper YAML frontmatter
Providing 10 powerful preset commands for common use cases
Validating command format and syntax
Creating well-organized folder structures
Offering installation guidance

Output: Complete slash commands ready to use in Claude Code

Official Command Structure Patterns

This skill generates commands following three official patterns from Anthropic documentation:

Pattern A: Simple (Context → Task)

Best for: Straightforward tasks with clear input/output Example: Code review, file updates, simple analysis Official Reference: code-review.md

Structure:

---
allowed-tools: Bash(git diff:*), Bash(git log:*)
description: Purpose description
---

## Context

- Current state: !`bash command`
- Additional data: !`another command`

## Your task

[Clear instructions with numbered steps]
[Success criteria]

When to use:

Simple, focused tasks
Quick analysis or reviews
Straightforward workflows
1-3 bash commands for context

Pattern B: Multi-Phase (Discovery → Analysis → Task)

Best for: Complex discovery and documentation tasks Example: Codebase analysis, comprehensive audits, system mapping Official Reference: codebase-analysis.md

Structure:

---
allowed-tools: Bash(find:*), Bash(tree:*), Bash(ls:*), Bash(grep:*), Bash(wc:*), Bash(du:*)
description: Comprehensive purpose
---

# Command Title

## Phase 1: Project Discovery

### Directory Structure

!`find . -type d | sort`

### File Count Analysis

!`find . -type f | wc -l`

## Phase 2: Detailed Analysis

[More discovery commands]
[File references with @]

## Phase 3: Your Task

Based on all discovered information, create:

1. **Deliverable 1**
   - Subsection
   - Details

2. **Deliverable 2**
   - Subsection
   - Details

At the end, write output to [filename].md

When to use:

Comprehensive analysis needed
Multiple discovery phases
Large amounts of context gathering
10+ bash commands for data collection
Generate detailed documentation files

Pattern C: Agent-Style (Role → Process → Guidelines)

Best for: Specialized expert roles and coordination Example: Domain experts, orchestrators, specialized advisors Official Reference: openapi-expert.md

Structure:

---
name: command-name
description: |
  Multi-line description for complex purpose
  explaining specialized role
color: yellow
---

You are a [specialized role] focusing on [domain expertise].

**Core Responsibilities:**

1. **Responsibility Area 1**
   - Specific tasks
   - Expected outputs

2. **Responsibility Area 2**
   - Specific tasks
   - Expected outputs

**Working Process:**

1. [Step 1 in workflow]
2. [Step 2 in workflow]
3. [Step 3 in workflow]

**Important Considerations:**

- [Guideline 1]
- [Guideline 2]
- [Constraint or best practice]

When you encounter [scenario], [action to take].

When to use:

Need specialized domain expertise
Orchestrating complex workflows
Coordinating multiple sub-processes
Acting as expert advisor
Require specific procedural guidelines

Comprehensive Naming Convention

Command File Naming Rules

All slash command files MUST follow kebab-case convention:

Format: [verb]-[noun].md, [noun]-[verb].md, or [domain]-[action].md

Rules:

Case: Lowercase only with hyphens as separators
Length: 2-4 words maximum
Characters: Only [a-z0-9-] allowed (letters, numbers, hyphens)
Start/End: Must begin and end with letter or number (not hyphen)
No: Spaces, underscores, camelCase, TitleCase, or special characters

Conversion Algorithm

User Input → Command Name

Input: "Analyze customer feedback and generate insights"
↓
1. Extract action: "analyze"
2. Extract target: "feedback"
3. Combine: "analyze-feedback"
4. Validate: Matches [a-z0-9-]+ pattern ✓
5. Output: analyze-feedback.md

More Examples:

"Review pull requests" → pr-review.md or review-pr.md
"Generate API documentation" → api-document.md or document-api.md
"Update README files" → update-readme.md or readme-update.md
"Audit security compliance" → security-audit.md or compliance-audit.md
"Research market trends" → research-market.md or market-research.md
"Analyze code quality" → code-analyze.md or analyze-code.md

Official Examples (From Anthropic Docs)

Correct:

✅ code-review.md (verb-noun)
✅ codebase-analysis.md (noun-noun compound)
✅ update-claude-md.md (verb-noun-qualifier)
✅ openapi-expert.md (domain-role)

Incorrect:

❌ code_review.md (snake_case - wrong)
❌ CodeReview.md (PascalCase - wrong)
❌ codeReview.md (camelCase - wrong)
❌ review.md (too vague - needs target)
❌ analyze-customer-feedback-data.md (too long - >4 words)

Bash Permission Patterns

Critical Rule: Subcommand-Level Specificity

❌ NEVER ALLOWED:

allowed-tools: Bash

Blanket Bash permission is prohibited per official Anthropic patterns.

❌ TOO BROAD (for commands with subcommands):

allowed-tools: Bash(git:*), Bash(gh:*), Bash(npm:*)

Command-level wildcards allow dangerous operations (git reset --hard, gh repo delete).

✅ REQUIRED (subcommand-level specificity):

allowed-tools: Bash(git add:*), Bash(git commit:*), Bash(git push:*), Bash(gh repo view:*)

Must specify exact subcommands for commands with subcommand hierarchies.

✅ OK (commands without subcommands):

allowed-tools: Bash(cp:*), Bash(mkdir -p:*), Bash(date:*), Bash(open:*)

Simple commands without subcommand hierarchies can use command-level.

Official Permission Patterns

Based on Anthropic's documented examples:

Git Operations (code-review, update-docs):

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

File Discovery (codebase-analysis):

allowed-tools: Bash(find:*), Bash(tree:*), Bash(ls:*), Bash(du:*)

Content Analysis (comprehensive discovery):

allowed-tools: Bash(grep:*), Bash(wc:*), Bash(head:*), Bash(tail:*), Bash(cat:*)

Data Processing (custom analysis):

allowed-tools: Bash(awk:*), Bash(sed:*), Bash(sort:*), Bash(uniq:*)

Combined Patterns (multi-phase commands):

allowed-tools: Bash(find:*), Bash(tree:*), Bash(ls:*), Bash(grep:*), Bash(wc:*), Bash(du:*), Bash(head:*), Bash(tail:*), Bash(cat:*), Bash(touch:*)

Permission Selection Guide

| Git Commands | git status, git diff, git log, git branch | code-review, commit-assist

| Discovery | find, tree, ls, du | codebase-analyze, structure-map

| Analysis | grep, wc, head, tail, cat | search-code, count-lines

| Update | git diff, find, grep | update-docs, sync-config

| Data Processing | awk, sed, sort, uniq | parse-data, format-output

| Comprehensive | All of the above | full-audit, system-analyze

Two Paths to Generate Commands

Path 1: Quick-Start Presets (30 seconds)

Choose from 10 powerful preset commands:

Business & Research:

/research-business - Comprehensive market research and competitive analysis
/research-content - Multi-platform content trend analysis and SEO strategy

Healthcare & Compliance: 3. /medical-translate - Translate medical terminology to 8th-10th grade (German/English) 4. /compliance-audit - HIPAA/GDPR/DSGVO compliance validation

Development & Integration: 5. /api-build - Generate complete API integration code with tests 6. /test-auto - Auto-generate comprehensive test suites

Documentation & Knowledge: 7. /docs-generate - Automated documentation creation 8. /knowledge-mine - Extract and structure insights from documents

Workflow & Productivity: 9. /workflow-analyze - Analyze and optimize business processes 10. /batch-agents - Launch and coordinate multiple agents for complex tasks

Path 2: Custom Command (5-7 Questions)

Create a completely custom command for your specific needs.

Question Flow (Custom Path)

Question 1: Command Purpose

"What should this slash command do?

Be specific about its purpose and when you'll use it.

Examples:

'Analyze customer feedback and generate actionable insights'
'Generate HIPAA-compliant API documentation'
'Research market trends and create content strategy'
'Extract key insights from research papers'

Your command's purpose: ___"

Question 2: Arguments (Auto-Determined)

The skill automatically determines if your command needs arguments based on the purpose.

If arguments are needed, they will use $ARGUMENTS format:

User types: /your-command argument1 argument2
Command receives: $ARGUMENTS = "argument1 argument2"

Examples:

/research-business "Tesla" "EV market" → $ARGUMENTS = "Tesla EV market"
/medical-translate "Myokardinfarkt" "de" → $ARGUMENTS = "Myokardinfarkt de"

No user input needed - skill decides intelligently.

Argument Short-Form Convention (MANDATORY)

Every flag/option MUST have a short form for quick command-line entry.

Rules:

Prefer 1-letter: -b for --branch, -v for --verbose
Use 2-letters only if needed: -nb for --no-branch (when -n conflicts)
Document both forms: Always show [-short|--long] in argument-hint

Format in argument-hint:

argument-hint: "[slug] [-b|--branch] [-v|--verbose]"

Format in Arguments table:

| Argument    | Short | Description           | Default |
| ----------- | ----- | --------------------- | ------- |
| `--branch`  | `-b`  | Create feature branch | false   |
| `--verbose` | `-v`  | Enable verbose output | false   |

Letter Selection Priority:

First letter of the flag name (--branch → -b)
Distinctive letter if first conflicts (--debug → -d, but if -d taken, use -D or -db)
Mnemonic association (--quiet → -q, --force → -f)

This is a MANDATORY success criterion - commands without short forms will fail validation.

Question 3: Which Tools?

"Which Claude Code tools should this command use?

Available tools:

Read - Read files
Write - Create files
Edit - Modify files
Bash - Execute shell commands (MUST specify exact commands)
Grep - Search code
Glob - Find files by pattern
Task - Launch agents

CRITICAL: For Bash, you MUST specify exact commands, not wildcards.

Bash Examples:

✅ Bash(git status:), Bash(git diff:), Bash(git log:*)
✅ Bash(find:), Bash(tree:), Bash(ls:*)
✅ Bash(grep:), Bash(wc:), Bash(head:*)
❌ Bash (wildcard not allowed per official patterns)

Tool Combination Examples:

Git command: Read, Bash(git status:), Bash(git diff:)
Code generator: Read, Write, Edit
Discovery command: Bash(find:), Bash(tree:), Bash(grep:*)
Analysis command: Read, Grep, Task (launch agents)

Your tools (comma-separated): ___"

Question 4: Agent Integration

"Does this command need to launch agents for specialized tasks?

Examples of when to use agents:

Complex analysis (launch rr-architect, rr-security)
Implementation tasks (launch rr-frontend, rr-backend)
Quality checks (launch rr-qa, rr-test-runner)

Options:

No agents - Command handles everything itself
Launch agents - Delegate to specialized agents

Your choice (1 or 2): ___"

If "2", ask: "Which agents should it launch? ___"

Question 5: Output Type

"What type of output should this command produce?

Analysis - Research report, insights, recommendations
Files - Generated code, documentation, configs
Action - Execute tasks, run workflows, deploy
Report - Structured report with findings and next steps

Your choice (1, 2, 3, or 4): ___"

Question 6: Model Preference (Optional)

"Which Claude model should this command use?

Default - Inherit from main conversation (recommended)
Sonnet - Best for complex tasks
Haiku - Fastest, cheapest (for simple commands)
Opus - Maximum capability (for critical tasks)

Your choice (1, 2, 3, or 4) or press Enter for default: ___"

Question 7: Additional Features (Optional)

"Any special features?

Optional features:

Bash execution - Run shell commands and include output (!command)
File references - Include file contents (@file.txt)
Context gathering - Read project files for context

Features you need (comma-separated) or press Enter to skip: ___"

Generation Process

After collecting answers:

Generate YAML Frontmatter:

---
description: [From command purpose]
argument-hint: [If $ARGUMENTS needed]
allowed-tools: [From tool selection]
model: [If specified]
---

Generate Command Body:

[Purpose-specific instructions]

[If uses agents]:

1. **Launch [agent-name]** with [specific task]
2. Coordinate workflow
3. Validate results

[If uses bash]:

- Context: !`bash command`

[If uses file refs]:

- Review: @file.txt

Success Criteria: [Based on output type]

Create Folder Structure:

generated-commands/[command-name]/
├── [command-name].md    # Command file (ROOT)
├── README.md            # Installation guide (ROOT)
├── TEST_EXAMPLES.md     # Testing examples (ROOT)
└── [folders if needed]  # standards/, examples/, scripts/

Validate Format:
✅ YAML frontmatter valid
✅ $ARGUMENTS syntax correct (if used)
✅ allowed-tools format proper
✅ Folder organization clean
Provide Installation Instructions:

Your command is ready!

Output location: generated-commands/[command-name]/

To install:
1. Copy the command file:
   cp generated-commands/[command-name]/[command-name].md .claude/commands/

2. Restart Claude Code (if already running)

3. Test:
   /[command-name] [arguments]

Plugin Command Invocation Format

When commands are installed in a plugin (via commands/ directory), users invoke them with the full namespace:

/plugin-name:command-name [arguments]

| ~/.claude/commands/ (user-level) | /command-name | /research-business

| plugin/commands/ (plugin) | /plugin-name:command-name | /my-plugin:research-business

Shortcut rules:

Commands like /my-plugin:research-business can be invoked as /research-business if no naming conflicts exist
Exception: When command-name = plugin-name (e.g., /foo:foo), you must use the full format—typing /foo alone is interpreted as the plugin prefix, not the command

Preset Command Details

1. /research-business

Purpose: Comprehensive business and market research

Arguments: $ARGUMENTS (company or market to research)

YAML:

---
description: Comprehensive business and market research with competitor analysis
argument-hint: [company/market] [industry]
allowed-tools: Read, Bash, Grep
---

What it does:

Market size and trends analysis
Competitor SWOT analysis
Opportunity identification
Industry landscape overview
Strategic recommendations

2. /research-content

Purpose: Multi-platform content trend analysis

Arguments: $ARGUMENTS (topic to research)

YAML:

---
description: Multi-platform content trend analysis for data-driven content strategy
argument-hint: [topic] [platforms]
allowed-tools: Read, Bash
---

What it does:

Analyze trends across Google, Reddit, YouTube, Medium, LinkedIn, X
User intent analysis (informational, commercial, transactional)
Content gap identification
SEO-optimized outline generation
Platform-specific publishing strategies

3. /medical-translate

Purpose: Translate medical terminology to patient-friendly language

Arguments: $ARGUMENTS (medical term and language)

YAML:

---
description: Translate medical terminology to 8th-10th grade reading level (German/English)
argument-hint: [medical-term] [de|en]
allowed-tools: Read
---

What it does:

Translate complex medical terms
Simplify to 8th-10th grade reading level
Validate with Flesch-Kincaid (EN) or Wiener Sachtextformel (DE)
Preserve clinical accuracy
Provide patient-friendly explanations

4. /compliance-audit

Purpose: Check code for regulatory compliance

Arguments: $ARGUMENTS (path and compliance standard)

YAML:

---
description: Audit code for HIPAA/GDPR/DSGVO compliance requirements
argument-hint: [code-path] [hipaa|gdpr|dsgvo|all]
allowed-tools: Read, Grep, Task
---

What it does:

Scan for PHI/PII handling
Check encryption requirements
Verify audit logging
Validate data subject rights
Generate compliance report

5. /api-build

Purpose: Generate complete API integration code

Arguments: $ARGUMENTS (API name and endpoints)

YAML:

---
description: Generate complete API client with error handling and tests
argument-hint: [api-name] [endpoints]
allowed-tools: Read, Write, Edit, Bash, Task
---

What it does:

Generate API client classes
Add error handling and retries
Create authentication logic
Generate unit and integration tests
Add usage documentation

6. /test-auto

Purpose: Auto-generate comprehensive test suites

Arguments: $ARGUMENTS (file path and test type)

YAML:

---
description: Auto-generate comprehensive test suite with coverage analysis
argument-hint: [file-path] [unit|integration|e2e]
allowed-tools: Read, Write, Bash
---

What it does:

Analyze code to test
Generate test cases (happy path, edge cases, errors)
Add test fixtures and mocks
Calculate coverage
Provide testing documentation

7. /docs-generate

Purpose: Automated documentation generation

Arguments: $ARGUMENTS (code path and doc type)

YAML:

---
description: Auto-generate documentation from code (API docs, README, architecture)
argument-hint: [code-path] [api|readme|architecture|all]
allowed-tools: Read, Write, Grep
---

What it does:

Extract code structure and functions
Generate API documentation
Create README with usage examples
Build architecture diagrams (Mermaid)
Add code examples

8. /knowledge-mine

Purpose: Extract structured insights from documents

Arguments: $ARGUMENTS (document path and output format)

YAML:

---
description: Extract and structure knowledge from documents into actionable insights
argument-hint: [doc-path] [faq|summary|kb|all]
allowed-tools: Read, Grep
---

What it does:

Read and analyze documents
Extract key insights
Generate FAQs
Create knowledge base articles
Summarize findings

9. /workflow-analyze

Purpose: Analyze and optimize business workflows

Arguments: $ARGUMENTS (workflow description)

YAML:

---
description: Analyze workflows and provide optimization recommendations
argument-hint: [workflow-description]
allowed-tools: Read, Task
---

What it does:

Map current workflow
Identify bottlenecks
Suggest automation opportunities
Calculate efficiency gains
Create implementation roadmap

10. /batch-agents

Purpose: Launch multiple coordinated agents

Arguments: $ARGUMENTS (agent names and task)

YAML:

---
description: Launch and coordinate multiple agents for complex tasks
argument-hint: [agent-names] [task-description]
allowed-tools: Task
---

What it does:

Parse agent list
Launch agents in parallel (if safe) or sequential
Coordinate outputs
Integrate results
Provide comprehensive summary

Output Structure

Commands are generated in your project's root directory:

[your-project]/
└── generated-commands/
    └── [command-name]/
        ├── [command-name].md      # Command file (ROOT level)
        ├── README.md              # Installation guide (ROOT level)
        ├── TEST_EXAMPLES.md       # Testing guide (ROOT level - if applicable)
        │
        ├── standards/             # Only if command has standards
        ├── examples/              # Only if command has examples
        └── scripts/               # Only if command has helper scripts

Organization Rules:

All .md files in ROOT directory
Supporting folders separate (standards/, examples/, scripts/)
No mixing of different types in same folder
Clean, hierarchical structure

Installation

After generation:

Review output:

ls generated-commands/[command-name]/

Copy to Claude Code (when ready):

# Project-level (this project only)
cp generated-commands/[command-name]/[command-name].md .claude/commands/

# User-level (all projects)
cp generated-commands/[command-name]/[command-name].md ~/.claude/commands/

Restart Claude Code (if running)
Test command:

/[command-name] [arguments]

Usage Examples

Generate a Preset Command

@slash-command-factory

Use the /research-business preset

Output: Complete business research command ready to install

Generate a Custom Command

@slash-command-factory

Create a custom command for analyzing customer feedback and generating product insights

Skill asks 5-7 questions → Generates complete command → Validates format → Provides installation steps

Command Format (What Gets Generated)

Example generated command (my-command.md):

---
description: Brief description of what the command does
argument-hint: [arg1] [arg2]
allowed-tools: Read, Write, Bash
model: claude-3-5-sonnet-20241022
---

# Command Instructions

Do [task] with "$ARGUMENTS":

1. **Step 1**: First action
2. **Step 2**: Second action
3. **Step 3**: Generate output

**Success Criteria**:

- Criterion 1
- Criterion 2
- Criterion 3

Validation

Every generated command is automatically validated for:

✅ Valid YAML frontmatter (proper syntax, required fields)
✅ Correct argument format ($ARGUMENTS, not $1 $2 $3)
✅ Short forms for all flags (mandatory 1-2 letter shortcuts)
✅ argument-hint includes both forms ([-b|--branch])
✅ Bash subcommand-level specificity (no Bash(git:*), use Bash(git add:*))
✅ allowed-tools syntax (comma-separated string)
✅ Clean folder organization (if folders used)
✅ No placeholder text

If validation fails, you'll get specific fix instructions.

Best Practices

For Command Design:

Keep commands focused (one clear purpose)
Use descriptive names (kebab-case for files)
Document expected arguments clearly
Include success criteria
Add examples in TEST_EXAMPLES.md

For Tool Selection:

Read: For analyzing files
Write/Edit: For generating/modifying files
Bash: For system commands, web research
Task: For launching agents
Grep/Glob: For searching code

For Agent Integration:

Use Task tool to launch agents
Specify which agents clearly
Coordinate outputs
Document agent roles

Important Notes

Arguments:

✅ Always use $ARGUMENTS (all arguments as one string)
❌ Never use $1, $2, $3 (positional - not used by this factory)

Folder Organization:

✅ All .md files in command root directory
✅ Supporting folders separate (standards/, examples/, scripts/)
✅ No mixing of different types

Output Location:

Commands generate to: ./generated-commands/[command-name]/
User copies to: .claude/commands/[command-name].md (when ready)

Example Invocations

Use a Preset

@slash-command-factory

Generate the /research-content preset command

→ Creates content research command with all features

Create Custom Healthcare Command

@slash-command-factory

Create a command that generates German PTV 10 therapy applications

Skill asks:

Purpose? (Generate PTV 10 applications)
Tools? (Read, Write, Task)
Agents? (Yes - health-sdk-builder related agents)
Output? (Files - therapy application documents)
Model? (Sonnet - for quality)

Result: /generate-ptv10 command ready to use

Create Business Intelligence Command

@slash-command-factory

Build a command for competitive SWOT analysis

Skill asks 5-7 questions → Generates /swot-analysis command → Validates → Ready to install

Integration with Factory Agents

Works with:

factory-guide (can delegate to this skill via prompts-guide pattern)
Existing slash commands (/build, /validate-output, etc.)

Complements:

skills-guide (builds Skills)
prompts-guide (builds Prompts)
agents-guide (builds Agents)
slash-command-factory (builds Commands) ← This skill

Complete ecosystem for building all Claude Code augmentations!

Output Validation

Generated commands are validated for:

YAML Frontmatter:

Has description field
Proper YAML syntax
Valid frontmatter fields only

Arguments:

Uses $ARGUMENTS if needed
Has argument-hint if $ARGUMENTS used
No $1, $2, $3 positional args
All flags have short forms (1-2 letters)
argument-hint shows [-short|--long] format

Tools:

Valid tool names
Proper comma-separated format
Appropriate for command purpose
Bash uses subcommand-level for git/gh/npm (not Bash(git:*))
No blanket Bash permission

Organization:

.md files in root
Folders properly separated
No scattered files

Success Criteria

Generated commands should:

✅ Have valid YAML frontmatter
✅ Use $ARGUMENTS (never positional)
✅ All flags have short forms (1-2 letters, e.g., -b|--branch)
✅ argument-hint shows both forms ([-b|--branch])
✅ Bash uses subcommand-level specificity for commands with subcommands

❌ Bash(git:*) - too broad

✅ Bash(git add:*), Bash(git commit:*) - correct
✅ No blanket Bash permission (Bash alone is prohibited)
✅ Work when copied to .claude/commands/
✅ Execute correctly with arguments
✅ Produce expected output
✅ Follow organizational standards

Build powerful custom slash commands in minutes!

安装

Overview

Official Command Structure Patterns

Pattern A: Simple (Context → Task)

Pattern B: Multi-Phase (Discovery → Analysis → Task)

Pattern C: Agent-Style (Role → Process → Guidelines)

Comprehensive Naming Convention

Command File Naming Rules

Conversion Algorithm

Official Examples (From Anthropic Docs)

Bash Permission Patterns

Critical Rule: Subcommand-Level Specificity

Official Permission Patterns

Permission Selection Guide

Two Paths to Generate Commands

Path 1: Quick-Start Presets (30 seconds)

Path 2: Custom Command (5-7 Questions)

Question Flow (Custom Path)

Question 1: Command Purpose

Question 2: Arguments (Auto-Determined)

Argument Short-Form Convention (MANDATORY)

Question 3: Which Tools?

Question 4: Agent Integration

Question 5: Output Type

Question 6: Model Preference (Optional)

Question 7: Additional Features (Optional)

Generation Process

Plugin Command Invocation Format

Preset Command Details

1. /research-business

2. /research-content

3. /medical-translate

4. /compliance-audit

5. /api-build

6. /test-auto

7. /docs-generate

8. /knowledge-mine

9. /workflow-analyze

10. /batch-agents

Output Structure

Installation

Usage Examples

Generate a Preset Command

Generate a Custom Command

Command Format (What Gets Generated)

Validation

Best Practices

Important Notes

Example Invocations

Use a Preset

Create Custom Healthcare Command

Create Business Intelligence Command

Integration with Factory Agents

Output Validation

Success Criteria