Slash Command Factory

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

What This Skill Does

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: 1. Case: Lowercase only with hyphens as separators 2. Length: 2-4 words maximum 3. Characters: Only [a-z0-9-] allowed (letters, numbers, hyphens) 4. Start/End: Must begin and end with letter or number (not hyphen) 5. 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: No Wildcards

❌ NEVER ALLOWED:

allowed-tools: Bash

This wildcard permission is prohibited per official Anthropic patterns.

✅ ALWAYS REQUIRED:

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

Must specify exact commands with wildcards only for subcommands.

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

Two Paths to Generate Commands

Path 1: Quick-Start Presets (30 seconds)

Choose from 10 powerful preset commands:

Business & Research: 1. /research-business - Comprehensive market research and competitive analysis 2. /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.

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: 1. No agents - Command handles everything itself 2. 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?

1. Analysis - Research report, insights, recommendations
2. Files - Generated code, documentation, configs
3. Action - Execute tasks, run workflows, deploy
4. 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?

1. Default - Inherit from main conversation (recommended)
2. Sonnet - Best for complex tasks
3. Haiku - Fastest, cheapest (for simple commands)
4. 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:

1. Generate YAML Frontmatter:

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

2. 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]

3. 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/

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

5. 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]

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:

1. Review output: bash ls generated-commands/[command-name]/

2. Copy to Claude Code (when ready): ```bash # 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/ ```

3. Restart Claude Code (if running)

4. Test command: bash /[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) - ✅ 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

Tools: - Valid tool names - Proper comma-separated format - Appropriate for command purpose

Organization: - .md files in root - Folders properly separated - No scattered files

Success Criteria

Generated commands should: - ✅ Have valid YAML frontmatter - ✅ Use $ARGUMENTS (never positional) - ✅ Work when copied to .claude/commands/ - ✅ Execute correctly with arguments - ✅ Produce expected output - ✅ Follow organizational standards

Version: 1.0.0 Last Updated: October 28, 2025 Compatible: Claude Code (all versions with slash command support)

Build powerful custom slash commands in minutes! ⚡