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:

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

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:

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]

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)

• ✅ 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! ⚡