Claude Code Slash Commands

A comprehensive collection of production-ready slash commands for Claude Code that provides intelligent automation and multi-agent orchestration capabilities for modern software development.

Overview

This repository provides 57 production-ready slash commands (15 workflows, 42 tools) that extend Claude Code's capabilities through:

• Workflows: Multi-agent orchestration systems that coordinate complex, multi-step operations across different domains
• Tools: Specialized single-purpose utilities for focused development tasks

System Requirements

• Claude Code installed and configured
• Git for repository management

Installation

Note: This repository uses the slash commands pattern. For a more modern approach, consider the Plugin Marketplace which provides similar functionality through a cleaner plugin architecture.

Slash Commands (This Repository)

# Navigate to Claude configuration directory
cd ~/.claude

# Clone the commands repository
git clone https://github.com/wshobson/commands.git

Plugin Marketplace (Alternative)

# Add the plugin marketplace
/plugin marketplace add https://github.com/wshobson/agents

# Install plugin collections
/plugin install claude-code-essentials

Available collections include: claude-code-essentials, full-stack-development, security-hardening, data-ml-pipeline, infrastructure-devops, and more.

Command Invocation

Commands are organized in tools/ and workflows/ directories and invoked using directory prefixes:

# Workflow invocation
/workflows:feature-development implement OAuth2 authentication

# Tool invocation
/tools:security-scan perform vulnerability assessment

# Multiple argument example
/tools:api-scaffold create user management endpoints with RBAC

Alternative Setup (No Prefixes)

To invoke commands without directory prefixes, copy files to the root directory:

cp tools/*.md .
cp workflows/*.md .

# Then invoke directly
/api-scaffold create REST endpoints
/feature-development implement payment system

Command Architecture

Workflows (15 commands)

Workflows implement multi-agent orchestration patterns for complex, cross-domain tasks. Each workflow analyzes requirements, delegates to specialized agents, and coordinates execution across multiple subsystems.

Core Development Workflows

Process Automation Workflows

Advanced Orchestration Workflows

Tools (42 commands)

Tools provide focused, single-purpose utilities for specific development operations. Each tool is optimized for its domain with production-ready implementations.

AI and Machine Learning (4 tools)

Agent Collaboration (3 tools)

Architecture and Code Quality (4 tools)

Data and Database (3 tools)

DevOps and Infrastructure (5 tools)

Testing and Development (6 tools)

Security and Compliance (3 tools)

Debugging and Analysis (4 tools)

Dependency and Configuration Management (3 tools)

Documentation and Collaboration (3 tools)

Operations and Context (4 tools)

Usage Patterns

Common Development Scenarios

Feature Implementation

# Complete feature with multi-agent orchestration
/workflows:feature-development OAuth2 authentication with JWT tokens

# API-first development
/tools:api-scaffold REST endpoints for user management with RBAC

# Test-driven approach
/workflows:tdd-cycle shopping cart with discount calculation logic

Debugging and Performance

# Intelligent issue resolution
/workflows:smart-fix high memory consumption in production workers

# Targeted error analysis
/tools:error-trace investigate Redis connection timeouts

# Performance optimization
/workflows:performance-optimization optimize database query performance

Security and Compliance

# Security assessment
/tools:security-scan OWASP Top 10 vulnerability scan

# Compliance verification
/tools:compliance-check GDPR data handling requirements

# Security hardening workflow
/workflows:security-hardening implement zero-trust architecture

Test-Driven Development

Standard TDD Flow

# Complete TDD cycle with orchestration
/workflows:tdd-cycle payment processing with Stripe integration

# Manual TDD phases for granular control
/tools:tdd-red create failing tests for order validation
/tools:tdd-green implement minimal order validation logic
/tools:tdd-refactor optimize validation performance

Command Composition Strategies

Sequential Execution Pattern

# Feature implementation pipeline
/workflows:feature-development real-time notifications with WebSockets
/tools:security-scan WebSocket implementation vulnerabilities
/workflows:performance-optimization WebSocket connection handling
/tools:deploy-checklist notification service deployment requirements
/tools:k8s-manifest WebSocket service with session affinity

Modernization Pipeline

# Legacy system upgrade
/workflows:legacy-modernize migrate monolith to microservices
/tools:deps-audit check dependency vulnerabilities
/tools:deps-upgrade update to latest stable versions
/tools:refactor-clean remove deprecated patterns
/tools:test-harness generate comprehensive test coverage
/tools:docker-optimize create optimized container images
/tools:k8s-manifest deploy with rolling update strategy

Command Selection Guidelines

Workflow vs Tool Decision Matrix

Workflow Selection Examples

Tool Selection Examples

Execution Best Practices

Context Optimization

1. Technology Stack Specification: Include framework versions, database systems, deployment targets
2. Constraint Definition: Specify performance requirements, security standards, compliance needs
3. Integration Requirements: Define external services, APIs, authentication methods
4. Output Preferences: Indicate coding standards, testing frameworks, documentation formats

Command Chaining Strategies

1. Progressive Enhancement: Start with workflows for foundation, refine with tools
2. Pipeline Construction: Chain commands in logical sequence for complete solutions
3. Iterative Refinement: Use tool outputs as inputs for subsequent commands
4. Parallel Execution: Run independent tools simultaneously when possible

Performance Considerations

• Workflows typically require 30-90 seconds for complete orchestration
• Tools execute in 5-30 seconds for focused operations
• Provide detailed requirements upfront to minimize iteration cycles
• Use saved context (context-save/context-restore) for multi-session projects

Technical Architecture

Command Structure

Each slash command is a markdown file with the following characteristics:

File Organization

~/.claude/commands/
├── workflows/          # Multi-agent orchestration commands
│   ├── feature-development.md
│   ├── smart-fix.md
│   └── ...
├── tools/             # Single-purpose utility commands
│   ├── api-scaffold.md
│   ├── security-scan.md
│   └── ...
└── README.md          # This documentation

Development Guidelines

Creating New Commands

Workflow Development

1. File Creation: Place in workflows/ directory with descriptive naming
2. Agent Orchestration: Define delegation logic for multiple specialists
3. Error Handling: Include fallback strategies and error recovery
4. Output Coordination: Specify how agent outputs should be combined

Tool Development

1. File Creation: Place in tools/ directory with single-purpose naming
2. Implementation: Provide complete, production-ready code generation
3. Framework Detection: Auto-detect and adapt to project stack
4. Best Practices: Include security, performance, and scalability considerations

Naming Conventions

• Use lowercase with hyphens: feature-name.md
• Be descriptive but concise: security-scan not scan
• Indicate action clearly: deps-upgrade not dependencies
• Maintain consistency with existing commands

Troubleshooting Guide

Diagnostic Steps

Performance Optimization

1. Context Caching: Use context-save for multi-session projects
2. Batch Operations: Combine related tasks in single workflow
3. Tool Selection: Use tools for known problems, workflows for exploration
4. Requirement Clarity: Detailed specifications reduce iteration cycles

Featured Command Implementations

Test-Driven Development Suite

Framework Support: Jest, Mocha, PyTest, RSpec, JUnit, Go testing, Rust tests

Security and Infrastructure

Security Tools Integration: Bandit, Safety, Trivy, Semgrep, Snyk, GitGuardian

Data and Database Operations

Zero-Downtime Patterns: Rolling migrations, feature flags, dual writes, backfill strategies

Performance and Optimization

Additional Resources

Documentation

• Claude Code Official Documentation
• Slash Commands Reference
• Subagents Architecture

Source Repositories

• Command Collection - Slash commands repository
• Plugin Marketplace - AI agents and workflow plugins
• Claude Code Repository - Official Claude Code CLI

Integration Examples

# Complete feature development pipeline
/workflows:feature-development user authentication system
/tools:security-scan authentication implementation
/tools:test-harness authentication test suite
/tools:docker-optimize authentication service
/tools:k8s-manifest authentication deployment
/tools:monitor-setup authentication metrics

License

MIT License - See LICENSE file for complete terms.

Support and Contribution

• Issues: GitHub Issues
• Contributions: Pull requests welcome following the development guidelines
• Questions: Open a discussion in the repository