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:

markdown

---
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:

markdown

---
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:

markdown

---
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

code

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:

yaml

allowed-tools: Bash

This wildcard permission is prohibited per official Anthropic patterns.

✅ ALWAYS REQUIRED:

yaml

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):

yaml

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

File Discovery (codebase-analysis):

yaml

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

Content Analysis (comprehensive discovery):

yaml

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

Data Processing (custom analysis):

yaml

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

Combined Patterns (multi-phase commands):

yaml

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

Command Type	Bash Permissions	Example Commands
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.

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:

yaml

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

•Generate Command Body:

markdown

[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:

code

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:

code

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

code

[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:
bash
```
ls generated-commands/[command-name]/
```

•

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/

•
Restart Claude Code (if running)
•
Test command:
bash
```
/[command-name] [arguments]
```

Usage Examples

Generate a Preset Command

code

@slash-command-factory

Use the /research-business preset

Output: Complete business research command ready to install

Generate a Custom Command

code

@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):

markdown

---
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

code

@slash-command-factory

Generate the /research-content preset command

→ Creates content research command with all features

Create Custom Healthcare Command

code

@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

code

@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! ⚡