Name: README
Author: yangjrun

Prompt file imported from yangjrun/novellus (.claude/commands/README.md). Fill in {{arguments}} before use. Copyright stays with the author.

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 56 production-ready slash commands (15 workflows, 41 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
Claude Code Subagents collection for workflow orchestration capabilities
Git for repository management

Installation

# Navigate to Claude configuration directory
cd ~/.claude

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

# Clone the agents repository (required for workflow execution)
git clone https://github.com/wshobson/agents.git

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

Command	Purpose	Agent Coordination
`feature-development`	End-to-end feature implementation	Backend, frontend, testing, deployment
`full-review`	Multi-perspective code analysis	Architecture, security, performance, quality
`smart-fix`	Intelligent problem resolution	Dynamic agent selection based on issue type
`tdd-cycle`	Test-driven development orchestration	Test writer, implementer, refactoring specialist

Process Automation Workflows

Command	Purpose	Scope
`git-workflow`	Version control process automation	Branching strategies, commit standards, PR templates
`improve-agent`	Agent optimization	Prompt engineering, performance tuning
`legacy-modernize`	Codebase modernization	Architecture migration, dependency updates, pattern refactoring
`ml-pipeline`	Machine learning pipeline construction	Data engineering, model training, deployment
`multi-platform`	Cross-platform development	Web, mobile, desktop coordination
`workflow-automate`	CI/CD pipeline automation	Build, test, deploy, monitor

Advanced Orchestration Workflows

Command	Primary Focus	Specialized Agents
`full-stack-feature`	Multi-tier implementation	Backend API, frontend UI, mobile, database
`security-hardening`	Security-first development	Threat modeling, vulnerability assessment, remediation
`data-driven-feature`	ML-powered functionality	Data science, feature engineering, model deployment
`performance-optimization`	System-wide optimization	Profiling, caching, query optimization, load testing
`incident-response`	Production issue resolution	Diagnostics, root cause analysis, hotfix deployment

Tools (41 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 (5 tools)

Command	Functionality	Key Features
`ai-assistant`	AI assistant implementation	LLM integration, conversation management, context handling
`ai-review`	ML code review	Model architecture validation, training pipeline review
`langchain-agent`	LangChain agent creation	RAG patterns, tool integration, memory management
`ml-pipeline`	ML pipeline construction	Data processing, training, evaluation, deployment
`prompt-optimize`	Prompt engineering	Performance testing, cost optimization, quality metrics

Architecture and Code Quality (4 tools)

Command	Purpose	Capabilities
`code-explain`	Code documentation	AST analysis, complexity metrics, flow diagrams
`code-migrate`	Migration automation	Framework upgrades, language porting, API migrations
`refactor-clean`	Code improvement	Pattern detection, dead code removal, structure optimization
`tech-debt`	Debt assessment	Complexity analysis, risk scoring, remediation planning

Data and Database (3 tools)

Command	Focus Area	Technologies
`data-pipeline`	ETL/ELT architecture	Apache Spark, Airflow, dbt, streaming platforms
`data-validation`	Data quality	Schema validation, anomaly detection, constraint checking
`db-migrate`	Database migrations	Schema versioning, zero-downtime strategies, rollback plans

DevOps and Infrastructure (6 tools)

Command	Domain	Implementation
`deploy-checklist`	Deployment preparation	Pre-flight checks, rollback procedures, monitoring setup
`docker-optimize`	Container optimization	Multi-stage builds, layer caching, size reduction
`k8s-manifest`	Kubernetes configuration	Deployments, services, ingress, autoscaling, security policies
`monitor-setup`	Observability	Metrics, logging, tracing, alerting rules
`slo-implement`	SLO/SLI definition	Error budgets, monitoring, automated responses
`workflow-automate`	Pipeline automation	CI/CD, GitOps, infrastructure as code

Testing and Development (6 tools)

Command	Testing Focus	Framework Support
`api-mock`	Mock generation	REST, GraphQL, gRPC, WebSocket
`api-scaffold`	Endpoint creation	CRUD operations, authentication, validation
`test-harness`	Test suite generation	Unit, integration, e2e, performance
`tdd-red`	Test-first development	Failing test creation, edge case coverage
`tdd-green`	Implementation	Minimal code to pass tests
`tdd-refactor`	Code improvement	Optimization while maintaining green tests

Security and Compliance (3 tools)

Command	Security Domain	Standards
`accessibility-audit`	WCAG compliance	ARIA, keyboard navigation, screen reader support
`compliance-check`	Regulatory compliance	GDPR, HIPAA, SOC2, PCI-DSS
`security-scan`	Vulnerability assessment	OWASP, CVE scanning, dependency audits

Debugging and Analysis (4 tools)

Command	Analysis Type	Output
`debug-trace`	Runtime analysis	Stack traces, memory profiles, execution paths
`error-analysis`	Error patterns	Root cause analysis, frequency analysis, impact assessment
`error-trace`	Production debugging	Log correlation, distributed tracing, error reproduction
`issue`	Issue tracking	Standardized templates, reproduction steps, acceptance criteria

Dependency and Configuration Management (3 tools)

Command	Management Area	Features
`config-validate`	Configuration management	Schema validation, environment variables, secrets handling
`deps-audit`	Dependency analysis	Security vulnerabilities, license compliance, version conflicts
`deps-upgrade`	Version management	Breaking change detection, compatibility testing, rollback support

Documentation and Collaboration (3 tools)

Command	Documentation Type	Format
`doc-generate`	API documentation	OpenAPI, JSDoc, TypeDoc, Sphinx
`pr-enhance`	Pull request optimization	Description generation, checklist creation, review suggestions
`standup-notes`	Status reporting	Progress tracking, blocker identification, next steps

Operations and Context (4 tools)

Command	Operational Focus	Use Case
`cost-optimize`	Resource optimization	Cloud spend analysis, right-sizing, reserved capacity
`onboard`	Environment setup	Development tools, access configuration, documentation
`context-save`	State persistence	Architecture decisions, configuration snapshots
`context-restore`	State recovery	Context reload, decision history, configuration restore

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

Criteria	Use Workflows	Use Tools
Problem Complexity	Multi-domain, cross-cutting concerns	Single domain, focused scope
Solution Clarity	Exploratory, undefined approach	Clear implementation path
Agent Coordination	Multiple specialists required	Single expertise sufficient
Implementation Scope	End-to-end features	Specific components
Control Level	Automated orchestration preferred	Manual control required

Workflow Selection Examples

Requirement	Recommended Workflow	Rationale
"Build complete authentication system"	`/workflows:feature-development`	Multi-tier implementation required
"Debug production performance issues"	`/workflows:smart-fix`	Unknown root cause, needs analysis
"Modernize legacy application"	`/workflows:legacy-modernize`	Complex refactoring across stack
"Implement ML-powered feature"	`/workflows:data-driven-feature`	Requires data science expertise

Tool Selection Examples

Task	Recommended Tool	Output
"Generate Kubernetes configs"	`/tools:k8s-manifest`	YAML manifests with best practices
"Audit security vulnerabilities"	`/tools:security-scan`	Vulnerability report with fixes
"Create API documentation"	`/tools:doc-generate`	OpenAPI/Swagger specifications
"Optimize Docker images"	`/tools:docker-optimize`	Multi-stage Dockerfile

Execution Best Practices

Context Optimization

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

Command Chaining Strategies

Progressive Enhancement: Start with workflows for foundation, refine with tools
Pipeline Construction: Chain commands in logical sequence for complete solutions
Iterative Refinement: Use tool outputs as inputs for subsequent commands
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:

Component	Description	Example
Filename	Determines command name	`api-scaffold.md` → `/tools:api-scaffold`
Content	Execution instructions	Agent prompts and orchestration logic
Variables	`{{arguments}}` placeholder	Captures and processes user input
Directory	Command category	`tools/` for utilities, `workflows/` for orchestration

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

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

Tool Development

File Creation: Place in tools/ directory with single-purpose naming
Implementation: Provide complete, production-ready code generation
Framework Detection: Auto-detect and adapt to project stack
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

Issue	Cause	Resolution
Command not recognized	File missing or misnamed	Verify file exists in correct directory
Slow execution	Normal workflow behavior	Workflows coordinate multiple agents (30-90s typical)
Incomplete output	Insufficient context	Provide technology stack and requirements
Integration failures	Path or configuration issues	Check file paths and dependencies

Performance Optimization

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

Featured Command Implementations

Test-Driven Development Suite

Command	Type	Capabilities
`tdd-cycle`	Workflow	Complete red-green-refactor orchestration with test coverage analysis
`tdd-red`	Tool	Failing test generation with edge case coverage and mocking
`tdd-green`	Tool	Minimal implementation to achieve test passage
`tdd-refactor`	Tool	Code optimization while maintaining test integrity

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

Security and Infrastructure

Command	Specialization	Key Features
`security-scan`	Vulnerability detection	SAST/DAST analysis, dependency scanning, secret detection
`docker-optimize`	Container optimization	Multi-stage builds, layer caching, size reduction (50-90% typical)
`k8s-manifest`	Kubernetes deployment	HPA, NetworkPolicy, PodSecurityPolicy, service mesh ready
`monitor-setup`	Observability	Prometheus metrics, Grafana dashboards, alert rules

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

Data and Database Operations

Command	Database Support	Migration Strategies
`db-migrate`	PostgreSQL, MySQL, MongoDB, DynamoDB	Blue-green, expand-contract, versioned schemas
`data-pipeline`	Batch and streaming	Apache Spark, Kafka, Airflow, dbt integration
`data-validation`	Schema and quality	Great Expectations, Pandera, custom validators

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

Performance and Optimization

Command	Analysis Type	Optimization Techniques
`performance-optimization`	Full-stack profiling	Query optimization, caching strategies, CDN configuration
`cost-optimize`	Cloud resource analysis	Right-sizing, spot instances, reserved capacity planning
`docker-optimize`	Container performance	Build cache optimization, minimal base images, layer reduction

Additional Resources

Documentation

Source Repositories

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

Install README and it becomes one more candidate the router can pick - when it fits.

A listing is a routing target with a manifest: what it does, which domains it covers, what it costs and who publishes it. Once installed it sits beside your own models and tools, is scored like any other candidate for each request, and shows up in the trace when it wins. Ratings come from workspaces that installed it, one per account.

# Claude Code Slash Commands A comprehensive collection of production-ready slash commands for [Claude Code](https://docs.anthropic.com/en/docs/claude-code) that provides intelligent automation and multi-agent orchestration capabilities for modern software development. ## Overview This repository provides **56 production-ready slash commands** (15 workflows, 41 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](https://docs.anthropic.com/en/docs/claude-code) installed and configured - [Claude Code Subagents](https://github.com/wshobson/agents) collection for workflow orchestration capabilities - Git for repository management ## Installation ```bash # Navigate to Claude configuration directory cd ~/.claude # Clone the commands repository git clone https://github.com/wshobson/commands.git # Clone the agents repository (required for workflow execution) git clone https://github.com/wshobson/agents.git ``` ## Command Invocation Commands are organized in `tools/` and `workflows/` directories and invoked using directory prefixes: ```bash # 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: ```bash 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 | Command | Purpose | Agent Coordination | |---------|---------|-------------------| | `feature-development` | End-to-end feature implementation | Backend, frontend, testing, deployment | | `full-review` | Multi-perspective code analysis | Architecture, security, performance, quality | | `smart-fix` | Intelligent problem resolution | Dynamic agent selection based on issue type | | `tdd-cycle` | Test-driven development orchestration | Test writer, implementer, refactoring specialist | #### Process Automation Workflows | Command | Purpose | Scope | |---------|---------|-------| | `git-workflow` | Version control process automation | Branching strategies, commit standards, PR templates | | `improve-agent` | Agent optimization | Prompt engineering, performance tuning | | `legacy-modernize` | Codebase modernization | Architecture migration, dependency updates, pattern refactoring | | `ml-pipeline` | Machine learning pipeline construction | Data engineering, model training, deployment | | `multi-platform` | Cross-platform development | Web, mobile, desktop coordination | | `workflow-automate` | CI/CD pipeline automation | Build, test, deploy, monitor | #### Advanced Orchestration Workflows | Command | Primary Focus | Specialized Agents | |---------|---------------|-------------------| | `full-stack-feature` | Multi-tier implementation | Backend API, frontend UI, mobile, database | | `security-hardening` | Security-first development | Threat modeling, vulnerability assessment, remediation | | `data-driven-feature` | ML-powered functionality | Data science, feature engineering, model deployment | | `performance-optimization` | System-wide optimization | Profiling, caching, query optimization, load testing | | `incident-response` | Production issue resolution | Diagnostics, root cause analysis, hotfix deployment | ### Tools (41 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 (5 tools) | Command | Functionality | Key Features | |---------|--------------|--------------| | `ai-assistant` | AI assistant implementation | LLM integration, conversation management, context handling | | `ai-review` | ML code review | Model architecture validation, training pipeline review | | `langchain-agent` | LangChain agent creation | RAG patterns, tool integration, memory management | | `ml-pipeline` | ML pipeline construction | Data processing, training, evaluation, deployment | | `prompt-optimize` | Prompt engineering | Performance testing, cost optimization, quality metrics | #### Architecture and Code Quality (4 tools) | Command | Purpose | Capabilities | |---------|---------|--------------| | `code-explain` | Code documentation | AST analysis, complexity metrics, flow diagrams | | `code-migrate` | Migration automation | Framework upgrades, language porting, API migrations | | `refactor-clean` | Code improvement | Pattern detection, dead code removal, structure optimization | | `tech-debt` | Debt assessment | Complexity analysis, risk scoring, remediation planning | #### Data and Database (3 tools) | Command | Focus Area | Technologies | |---------|------------|--------------| | `data-pipeline` | ETL/ELT architecture | Apache Spark, Airflow, dbt, streaming platforms | | `data-validation` | Data quality | Schema validation, anomaly detection, constraint checking | | `db-migrate` | Database migrations | Schema versioning, zero-downtime strategies, rollback plans | #### DevOps and Infrastructure (6 tools) | Command | Domain | Implementation | |---------|--------|----------------| | `deploy-checklist` | Deployment preparation | Pre-flight checks, rollback procedures, monitoring setup | | `docker-optimize` | Container optimization | Multi-stage builds, layer caching, size reduction | | `k8s-manifest` | Kubernetes configuration | Deployments, services, ingress, autoscaling, security policies | | `monitor-setup` | Observability | Metrics, logging, tracing, alerting rules | | `slo-implement` | SLO/SLI definition | Error budgets, monitoring, automated responses | | `workflow-automate` | Pipeline automation | CI/CD, GitOps, infrastructure as code | #### Testing and Development (6 tools) | Command | Testing Focus | Framework Support | |---------|---------------|-------------------| | `api-mock` | Mock generation | REST, GraphQL, gRPC, WebSocket | | `api-scaffold` | Endpoint creation | CRUD operations, authentication, validation | | `test-harness` | Test suite generation | Unit, integration, e2e, performance | | `tdd-red` | Test-first development | Failing test creation, edge case coverage | | `tdd-green` | Implementation | Minimal code to pass tests | | `tdd-refactor` | Code improvement | Optimization while maintaining green tests | #### Security and Compliance (3 tools) | Command | Security Domain | Standards | |---------|-----------------|-----------| | `accessibility-audit` | WCAG compliance | ARIA, keyboard navigation, screen reader support | | `compliance-check` | Regulatory compliance | GDPR, HIPAA, SOC2, PCI-DSS | | `security-scan` | Vulnerability assessment | OWASP, CVE scanning, dependency audits | #### Debugging and Analysis (4 tools) | Command | Analysis Type | Output | |---------|---------------|--------| | `debug-trace` | Runtime analysis | Stack traces, memory profiles, execution paths | | `error-analysis` | Error patterns | Root cause analysis, frequency analysis, impact assessment | | `error-trace` | Production debugging | Log correlation, distributed tracing, error reproduction | | `issue` | Issue tracking | Standardized templates, reproduction steps, acceptance criteria | #### Dependency and Configuration Management (3 tools) | Command | Management Area | Features | |---------|-----------------|----------| | `config-validate` | Configuration management | Schema validation, environment variables, secrets handling | | `deps-audit` | Dependency analysis | Security vulnerabilities, license compliance, version conflicts | | `deps-upgrade` | Version management | Breaking change detection, compatibility testing, rollback support | #### Documentation and Collaboration (3 tools) | Command | Documentation Type | Format | |---------|-------------------|--------| | `doc-generate` | API documentation | OpenAPI, JSDoc, TypeDoc, Sphinx | | `pr-enhance` | Pull request optimization | Description generation, checklist creation, review suggestions | | `standup-notes` | Status reporting | Progress tracking, blocker identification, next steps | #### Operations and Context (4 tools) | Command | Operational Focus | Use Case | |---------|------------------|----------| | `cost-optimize` | Resource optimization | Cloud spend analysis, right-sizing, reserved capacity | | `onboard` | Environment setup | Development tools, access configuration, documentation | | `context-save` | State persistence | Architecture decisions, configuration snapshots | | `context-restore` | State recovery | Context reload, decision history, configuration restore | ## Usage Patterns ### Common Development Scenarios #### Feature Implementation ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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 | Criteria | Use Workflows | Use Tools | |----------|--------------|-----------| | **Problem Complexity** | Multi-domain, cross-cutting concerns | Single domain, focused scope | | **Solution Clarity** | Exploratory, undefined approach | Clear implementation path | | **Agent Coordination** | Multiple specialists required | Single expertise sufficient | | **Implementation Scope** | End-to-end features | Specific components | | **Control Level** | Automated orchestration preferred | Manual control required | ### Workflow Selection Examples | Requirement | Recommended Workflow | Rationale | |-------------|---------------------|-----------| | "Build complete authentication system" | `/workflows:feature-development` | Multi-tier implementation required | | "Debug production performance issues" | `/workflows:smart-fix` | Unknown root cause, needs analysis | | "Modernize legacy application" | `/workflows:legacy-modernize` | Complex refactoring across stack | | "Implement ML-powered feature" | `/workflows:data-driven-feature` | Requires data science expertise | ### Tool Selection Examples | Task | Recommended Tool | Output | |------|-----------------|--------| | "Generate Kubernetes configs" | `/tools:k8s-manifest` | YAML manifests with best practices | | "Audit security vulnerabilities" | `/tools:security-scan` | Vulnerability report with fixes | | "Create API documentation" | `/tools:doc-generate` | OpenAPI/Swagger specifications | | "Optimize Docker images" | `/tools:docker-optimize` | Multi-stage Dockerfile | ## 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: | Component | Description | Example | |-----------|-------------|---------| | **Filename** | Determines command name | `api-scaffold.md` → `/tools:api-scaffold` | | **Content** | Execution instructions | Agent prompts and orchestration logic | | **Variables** | `{{arguments}}` placeholder | Captures and processes user input | | **Directory** | Command category | `tools/` for utilities, `workflows/` for orchestration | ### 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 | Issue | Cause | Resolution | |-------|-------|------------| | Command not recognized | File missing or misnamed | Verify file exists in correct directory | | Slow execution | Normal workflow behavior | Workflows coordinate multiple agents (30-90s typical) | | Incomplete output | Insufficient context | Provide technology stack and requirements | | Integration failures | Path or configuration issues | Check file paths and dependencies | ### 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 | Command | Type | Capabilities | |---------|------|--------------| | `tdd-cycle` | Workflow | Complete red-green-refactor orchestration with test coverage analysis | | `tdd-red` | Tool | Failing test generation with edge case coverage and mocking | | `tdd-green` | Tool | Minimal implementation to achieve test passage | | `tdd-refactor` | Tool | Code optimization while maintaining test integrity | **Framework Support**: Jest, Mocha, PyTest, RSpec, JUnit, Go testing, Rust tests ### Security and Infrastructure | Command | Specialization | Key Features | |---------|---------------|--------------| | `security-scan` | Vulnerability detection | SAST/DAST analysis, dependency scanning, secret detection | | `docker-optimize` | Container optimization | Multi-stage builds, layer caching, size reduction (50-90% typical) | | `k8s-manifest` | Kubernetes deployment | HPA, NetworkPolicy, PodSecurityPolicy, service mesh ready | | `monitor-setup` | Observability | Prometheus metrics, Grafana dashboards, alert rules | **Security Tools Integration**: Bandit, Safety, Trivy, Semgrep, Snyk, GitGuardian ### Data and Database Operations | Command | Database Support | Migration Strategies | |---------|-----------------|---------------------| | `db-migrate` | PostgreSQL, MySQL, MongoDB, DynamoDB | Blue-green, expand-contract, versioned schemas | | `data-pipeline` | Batch and streaming | Apache Spark, Kafka, Airflow, dbt integration | | `data-validation` | Schema and quality | Great Expectations, Pandera, custom validators | **Zero-Downtime Patterns**: Rolling migrations, feature flags, dual writes, backfill strategies ### Performance and Optimization | Command | Analysis Type | Optimization Techniques | |---------|--------------|------------------------| | `performance-optimization` | Full-stack profiling | Query optimization, caching strategies, CDN configuration | | `cost-optimize` | Cloud resource analysis | Right-sizing, spot instances, reserved capacity planning | | `docker-optimize` | Container performance | Build cache optimization, minimal base images, layer reduction | ## Additional Resources ### Documentation - [Claude Code Official Documentation](https://docs.anthropic.com/en/docs/claude-code) - [Slash Commands Reference](https://docs.anthropic.com/en/docs/claude-code/slash-commands) - [Subagents Architecture](https://docs.anthropic.com/en/docs/claude-code/sub-agents) ### Source Repositories - [Command Collection](https://github.com/wshobson/commands) - [Agent Collection](https://github.com/wshobson/agents) - [Claude Code Repository](https://github.com/anthropics/claude-code) ### Integration Examples ```bash # 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 LICE

{ "prompt": "# Claude Code Slash Commands\n\nA comprehensive collection of production-ready slash commands for [Claude Code](https://docs.anthropic.com/en/docs/claude-code) that provides intelligent automation and multi-agent orchestration capabilities for modern software development.\n\n## Overview\n\nThis repository provides **56 production-ready slash commands** (15 workflows, 41 tools) that extend Claude Code's capabilities through:\n\n- **Workflows**: Multi-agent orchestration systems that coordinate complex, multi-step operations across different domains\n- **Tools**: Specialized single-purpose utilities for focused development tasks\n\n## System Requirements\n\n- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed and configured\n- [Claude Code Subagents](https://github.com/wshobson/agents) collection for workflow orchestration capabilities\n- Git for repository management\n\n## Installation\n\n```bash\n# Navigate to Claude configuration directory\ncd ~/.claude\n\n# Clone the commands repository\ngit clone https://github.com/wshobson/commands.git\n\n# Clone the agents repository (required for workflow execution)\ngit clone https://github.com/wshobson/agents.git\n```\n\n## Command Invocation\n\nCommands are organized in `tools/` and `workflows/` directories and invoked using directory prefixes:\n\n```bash\n# Workflow invocation\n/workflows:feature-development implement OAuth2 authentication\n\n# Tool invocation\n/tools:security-scan perform vulnerability assessment\n\n# Multiple argument example\n/tools:api-scaffold create user management endpoints with RBAC\n```\n\n### Alternative Setup (No Prefixes)\n\nTo invoke commands without directory prefixes, copy files to the root directory:\n\n```bash\ncp tools/*.md .\ncp workflows/*.md .\n\n# Then invoke directly\n/api-scaffold create REST endpoints\n/feature-development implement payment system\n```\n\n## Command Architecture\n\n### Workflows (15 commands)\n\nWorkflows implement multi-agent orchestration patterns for complex, cross-domain tasks. Each workflow analyzes requirements, delegates to specialized agents, and coordinates execution across multiple subsystems.\n\n#### Core Development Workflows\n\n| Command | Purpose | Agent Coordination |\n|---------|---------|-------------------|\n| `feature-development` | End-to-end feature implementation | Backend, frontend, testing, deployment |\n| `full-review` | Multi-perspective code analysis | Architecture, security, performance, quality |\n| `smart-fix` | Intelligent problem resolution | Dynamic agent selection based on issue type |\n| `tdd-cycle` | Test-driven development orchestration | Test writer, implementer, refactoring specialist |\n\n#### Process Automation Workflows\n\n| Command | Purpose | Scope |\n|---------|---------|-------|\n| `git-workflow` | Version control process automation | Branching strategies, commit standards, PR templates |\n| `improve-agent` | Agent optimization | Prompt engineering, performance tuning |\n| `legacy-modernize` | Codebase modernization | Architecture migration, dependency updates, pattern refactoring |\n| `ml-pipeline` | Machine learning pipeline construction | Data engineering, model training, deployment |\n| `multi-platform` | Cross-platform development | Web, mobile, desktop coordination |\n| `workflow-automate` | CI/CD pipeline automation | Build, test, deploy, monitor |\n\n#### Advanced Orchestration Workflows\n\n| Command | Primary Focus | Specialized Agents |\n|---------|---------------|-------------------|\n| `full-stack-feature` | Multi-tier implementation | Backend API, frontend UI, mobile, database |\n| `security-hardening` | Security-first development | Threat modeling, vulnerability assessment, remediation |\n| `data-driven-feature` | ML-powered functionality | Data science, feature engineering, model deployment |\n| `performance-optimization` | System-wide optimization | Profiling, caching, query optimization, load testing |\n| `incident-response` | Production issue resolution | Diagnostics, root cause analysis, hotfix deployment |\n\n### Tools (41 commands)\n\nTools provide focused, single-purpose utilities for specific development operations. Each tool is optimized for its domain with production-ready implementations.\n\n#### AI and Machine Learning (5 tools)\n\n| Command | Functionality | Key Features |\n|---------|--------------|--------------|\n| `ai-assistant` | AI assistant implementation | LLM integration, conversation management, context handling |\n| `ai-review` | ML code review | Model architecture validation, training pipeline review |\n| `langchain-agent` | LangChain agent creation | RAG patterns, tool integration, memory management |\n| `ml-pipeline` | ML pipeline construction | Data processing, training, evaluation, deployment |\n| `prompt-optimize` | Prompt engineering | Performance testing, cost optimization, quality metrics |\n\n#### Architecture and Code Quality (4 tools)\n\n| Command | Purpose | Capabilities |\n|---------|---------|--------------|\n| `code-explain` | Code documentation | AST analysis, complexity metrics, flow diagrams |\n| `code-migrate` | Migration automation | Framework upgrades, language porting, API migrations |\n| `refactor-clean` | Code improvement | Pattern detection, dead code removal, structure optimization |\n| `tech-debt` | Debt assessment | Complexity analysis, risk scoring, remediation planning |\n\n#### Data and Database (3 tools)\n\n| Command | Focus Area | Technologies |\n|---------|------------|--------------|\n| `data-pipeline` | ETL/ELT architecture | Apache Spark, Airflow, dbt, streaming platforms |\n| `data-validation` | Data quality | Schema validation, anomaly detection, constraint checking |\n| `db-migrate` | Database migrations | Schema versioning, zero-downtime strategies, rollback plans |\n\n#### DevOps and Infrastructure (6 tools)\n\n| Command | Domain | Implementation |\n|---------|--------|----------------|\n| `deploy-checklist` | Deployment preparation | Pre-flight checks, rollback procedures, monitoring setup |\n| `docker-optimize` | Container optimization | Multi-stage builds, layer caching, size reduction |\n| `k8s-manifest` | Kubernetes configuration | Deployments, services, ingress, autoscaling, security policies |\n| `monitor-setup` | Observability | Metrics, logging, tracing, alerting rules |\n| `slo-implement` | SLO/SLI definition | Error budgets, monitoring, automated responses |\n| `workflow-automate` | Pipeline automation | CI/CD, GitOps, infrastructure as code |\n\n#### Testing and Development (6 tools)\n\n| Command | Testing Focus | Framework Support |\n|---------|---------------|-------------------|\n| `api-mock` | Mock generation | REST, GraphQL, gRPC, WebSocket |\n| `api-scaffold` | Endpoint creation | CRUD operations, authentication, validation |\n| `test-harness` | Test suite generation | Unit, integration, e2e, performance |\n| `tdd-red` | Test-first development | Failing test creation, edge case coverage |\n| `tdd-green` | Implementation | Minimal code to pass tests |\n| `tdd-refactor` | Code improvement | Optimization while maintaining green tests |\n\n#### Security and Compliance (3 tools)\n\n| Command | Security Domain | Standards |\n|---------|-----------------|-----------|\n| `accessibility-audit` | WCAG compliance | ARIA, keyboard navigation, screen reader support |\n| `compliance-check` | Regulatory compliance | GDPR, HIPAA, SOC2, PCI-DSS |\n| `security-scan` | Vulnerability assessment | OWASP, CVE scanning, dependency audits |\n\n#### Debugging and Analysis (4 tools)\n\n| Command | Analysis Type | Output |\n|---------|---------------|--------|\n| `debug-trace` | Runtime analysis | Stack traces, memory profiles, execution paths |\n| `error-analysis` | Error patterns | Root cause analysis, frequency analysis, impact assessment |\n| `error-trace` | Production debugging | Log correlation, distributed tracing, error reproduction |\n| `issue` | Issue tracking | Standardized templates, reproduction steps, acceptance criteria |\n\n#### Dependency and Configuration Management (3 tools)\n\n| Command | Management Area | Features |\n|---------|-----------------|----------|\n| `config-validate` | Configuration management | Schema validation, environment variables, secrets handling |\n| `deps-audit` | Dependency analysis | Security vulnerabilities, license compliance, version conflicts |\n| `deps-upgrade` | Version management | Breaking change detection, compatibility testing, rollback support |\n\n#### Documentation and Collaboration (3 tools)\n\n| Command | Documentation Type | Format |\n|---------|-------------------|--------|\n| `doc-generate` | API documentation | OpenAPI, JSDoc, TypeDoc, Sphinx |\n| `pr-enhance` | Pull request optimization | Description generation, checklist creation, review suggestions |\n| `standup-notes` | Status reporting | Progress tracking, blocker identification, next steps |\n\n#### Operations and Context (4 tools)\n\n| Command | Operational Focus | Use Case |\n|---------|------------------|----------|\n| `cost-optimize` | Resource optimization | Cloud spend analysis, right-sizing, reserved capacity |\n| `onboard` | Environment setup | Development tools, access configuration, documentation |\n| `context-save` | State persistence | Architecture decisions, configuration snapshots |\n| `context-restore` | State recovery | Context reload, decision history, configuration restore |\n\n## Usage Patterns\n\n### Common Development Scenarios\n\n#### Feature Implementation\n```bash\n# Complete feature with multi-agent orchestration\n/workflows:feature-development OAuth2 authentication with JWT tokens\n\n# API-first development\n/tools:api-scaffold REST endpoints for user management with RBAC\n\n# Test-driven approach\n/workflows:tdd-cycle shopping cart with discount calculation logic\n```\n\n#### Debugging and Performance\n```bash\n# Intelligent issue resolution\n/workflows:smart-fix high memory consumption in production workers\n\n# Targeted error analysis\n/tools:error-trace investigate Redis connection timeouts\n\n# Performance optimization\n/workflows:performance-optimization optimize database query performance\n```\n\n#### Security and Compliance\n```bash\n# Security assessment\n/tools:security-scan OWASP Top 10 vulnerability scan\n\n# Compliance verification\n/tools:compliance-check GDPR data handling requirements\n\n# Security hardening workflow\n/workflows:security-hardening implement zero-trust architecture\n```\n\n### Test-Driven Development\n\n#### Standard TDD Flow\n```bash\n# Complete TDD cycle with orchestration\n/workflows:tdd-cycle payment processing with Stripe integration\n\n# Manual TDD phases for granular control\n/tools:tdd-red create failing tests for order validation\n/tools:tdd-green implement minimal order validation logic\n/tools:tdd-refactor optimize validation performance\n```\n\n### Command Composition Strategies\n\n#### Sequential Execution Pattern\n```bash\n# Feature implementation pipeline\n/workflows:feature-development real-time notifications with WebSockets\n/tools:security-scan WebSocket implementation vulnerabilities\n/workflows:performance-optimization WebSocket connection handling\n/tools:deploy-checklist notification service deployment requirements\n/tools:k8s-manifest WebSocket service with session affinity\n```\n\n#### Modernization Pipeline\n```bash\n# Legacy system upgrade\n/workflows:legacy-modernize migrate monolith to microservices\n/tools:deps-audit check dependency vulnerabilities\n/tools:deps-upgrade update to latest stable versions\n/tools:refactor-clean remove deprecated patterns\n/tools:test-harness generate comprehensive test coverage\n/tools:docker-optimize create optimized container images\n/tools:k8s-manifest deploy with rolling update strategy\n```\n\n## Command Selection Guidelines\n\n### Workflow vs Tool Decision Matrix\n\n| Criteria | Use Workflows | Use Tools |\n|----------|--------------|-----------|\n| **Problem Complexity** | Multi-domain, cross-cutting concerns | Single domain, focused scope |\n| **Solution Clarity** | Exploratory, undefined approach | Clear implementation path |\n| **Agent Coordination** | Multiple specialists required | Single expertise sufficient |\n| **Implementation Scope** | End-to-end features | Specific components |\n| **Control Level** | Automated orchestration preferred | Manual control required |\n\n### Workflow Selection Examples\n\n| Requirement | Recommended Workflow | Rationale |\n|-------------|---------------------|-----------|\n| \"Build complete authentication system\" | `/workflows:feature-development` | Multi-tier implementation required |\n| \"Debug production performance issues\" | `/workflows:smart-fix` | Unknown root cause, needs analysis |\n| \"Modernize legacy application\" | `/workflows:legacy-modernize` | Complex refactoring across stack |\n| \"Implement ML-powered feature\" | `/workflows:data-driven-feature` | Requires data science expertise |\n\n### Tool Selection Examples\n\n| Task | Recommended Tool | Output |\n|------|-----------------|--------|\n| \"Generate Kubernetes configs\" | `/tools:k8s-manifest` | YAML manifests with best practices |\n| \"Audit security vulnerabilities\" | `/tools:security-scan` | Vulnerability report with fixes |\n| \"Create API documentation\" | `/tools:doc-generate` | OpenAPI/Swagger specifications |\n| \"Optimize Docker images\" | `/tools:docker-optimize` | Multi-stage Dockerfile |\n\n## Execution Best Practices\n\n### Context Optimization\n\n1. **Technology Stack Specification**: Include framework versions, database systems, deployment targets\n2. **Constraint Definition**: Specify performance requirements, security standards, compliance needs\n3. **Integration Requirements**: Define external services, APIs, authentication methods\n4. **Output Preferences**: Indicate coding standards, testing frameworks, documentation formats\n\n### Command Chaining Strategies\n\n1. **Progressive Enhancement**: Start with workflows for foundation, refine with tools\n2. **Pipeline Construction**: Chain commands in logical sequence for complete solutions\n3. **Iterative Refinement**: Use tool outputs as inputs for subsequent commands\n4. **Parallel Execution**: Run independent tools simultaneously when possible\n\n### Performance Considerations\n\n- Workflows typically require 30-90 seconds for complete orchestration\n- Tools execute in 5-30 seconds for focused operations\n- Provide detailed requirements upfront to minimize iteration cycles\n- Use saved context (`context-save`/`context-restore`) for multi-session projects\n\n## Technical Architecture\n\n### Command Structure\n\nEach slash command is a markdown file with the following characteristics:\n\n| Component | Description | Example |\n|-----------|-------------|---------|\n| **Filename** | Determines command name | `api-scaffold.md` → `/tools:api-scaffold` |\n| **Content** | Execution instructions | Agent prompts and orchestration logic |\n| **Variables** | `{{arguments}}` placeholder | Captures and processes user input |\n| **Directory** | Command category | `tools/` for utilities, `workflows/` for orchestration |\n\n### File Organization\n\n```\n~/.claude/commands/\n├── workflows/ # Multi-agent orchestration commands\n│ ├── feature-development.md\n│ ├── smart-fix.md\n│ └── ...\n├── tools/ # Single-purpose utility commands\n│ ├── api-scaffold.md\n│ ├── security-scan.md\n│ └── ...\n└── README.md # This documentation\n```\n\n## Development Guidelines\n\n### Creating New Commands\n\n#### Workflow Development\n\n1. **File Creation**: Place in `workflows/` directory with descriptive naming\n2. **Agent Orchestration**: Define delegation logic for multiple specialists\n3. **Error Handling**: Include fallback strategies and error recovery\n4. **Output Coordination**: Specify how agent outputs should be combined\n\n#### Tool Development\n\n1. **File Creation**: Place in `tools/` directory with single-purpose naming\n2. **Implementation**: Provide complete, production-ready code generation\n3. **Framework Detection**: Auto-detect and adapt to project stack\n4. **Best Practices**: Include security, performance, and scalability considerations\n\n### Naming Conventions\n\n- Use lowercase with hyphens: `feature-name.md`\n- Be descriptive but concise: `security-scan` not `scan`\n- Indicate action clearly: `deps-upgrade` not `dependencies`\n- Maintain consistency with existing commands\n\n## Troubleshooting Guide\n\n### Diagnostic Steps\n\n| Issue | Cause | Resolution |\n|-------|-------|------------|\n| Command not recognized | File missing or misnamed | Verify file exists in correct directory |\n| Slow execution | Normal workflow behavior | Workflows coordinate multiple agents (30-90s typical) |\n| Incomplete output | Insufficient context | Provide technology stack and requirements |\n| Integration failures | Path or configuration issues | Check file paths and dependencies |\n\n### Performance Optimization\n\n1. **Context Caching**: Use `context-save` for multi-session projects\n2. **Batch Operations**: Combine related tasks in single workflow\n3. **Tool Selection**: Use tools for known problems, workflows for exploration\n4. **Requirement Clarity**: Detailed specifications reduce iteration cycles\n\n## Featured Command Implementations\n\n### Test-Driven Development Suite\n\n| Command | Type | Capabilities |\n|---------|------|--------------|\n| `tdd-cycle` | Workflow | Complete red-green-refactor orchestration with test coverage analysis |\n| `tdd-red` | Tool | Failing test generation with edge case coverage and mocking |\n| `tdd-green` | Tool | Minimal implementation to achieve test passage |\n| `tdd-refactor` | Tool | Code optimization while maintaining test integrity |\n\n**Framework Support**: Jest, Mocha, PyTest, RSpec, JUnit, Go testing, Rust tests\n\n### Security and Infrastructure\n\n| Command | Specialization | Key Features |\n|---------|---------------|--------------|\n| `security-scan` | Vulnerability detection | SAST/DAST analysis, dependency scanning, secret detection |\n| `docker-optimize` | Container optimization | Multi-stage builds, layer caching, size reduction (50-90% typical) |\n| `k8s-manifest` | Kubernetes deployment | HPA, NetworkPolicy, PodSecurityPolicy, service mesh ready |\n| `monitor-setup` | Observability | Prometheus metrics, Grafana dashboards, alert rules |\n\n**Security Tools Integration**: Bandit, Safety, Trivy, Semgrep, Snyk, GitGuardian\n\n### Data and Database Operations\n\n| Command | Database Support | Migration Strategies |\n|---------|-----------------|---------------------|\n| `db-migrate` | PostgreSQL, MySQL, MongoDB, DynamoDB | Blue-green, expand-contract, versioned schemas |\n| `data-pipeline` | Batch and streaming | Apache Spark, Kafka, Airflow, dbt integration |\n| `data-validation` | Schema and quality | Great Expectations, Pandera, custom validators |\n\n**Zero-Downtime Patterns**: Rolling migrations, feature flags, dual writes, backfill strategies\n\n### Performance and Optimization\n\n| Command | Analysis Type | Optimization Techniques |\n|---------|--------------|------------------------|\n| `performance-optimization` | Full-stack profiling | Query optimization, caching strategies, CDN configuration |\n| `cost-optimize` | Cloud resource analysis | Right-sizing, spot instances, reserved capacity planning |\n| `docker-optimize` | Container performance | Build cache optimization, minimal base images, layer reduction |\n\n## Additional Resources\n\n### Documentation\n\n- [Claude Code Official Documentation](https://docs.anthropic.com/en/docs/claude-code)\n- [Slash Commands Reference](https://docs.anthropic.com/en/docs/claude-code/slash-commands)\n- [Subagents Architecture](https://docs.anthropic.com/en/docs/claude-code/sub-agents)\n\n### Source Repositories\n\n- [Command Collection](https://github.com/wshobson/commands)\n- [Agent Collection](https://github.com/wshobson/agents)\n- [Claude Code Repository](https://github.com/anthropics/claude-code)\n\n### Integration Examples\n\n```bash\n# Complete feature development pipeline\n/workflows:feature-development user authentication system\n/tools:security-scan authentication implementation\n/tools:test-harness authentication test suite\n/tools:docker-optimize authentication service\n/tools:k8s-manifest authentication deployment\n/tools:monitor-setup authentication metrics\n```\n\n## License\n\nMIT License - See LICE", "variables": [ "arguments" ], "notes": "A comprehensive collection of production-ready slash commands for [Claude Code](https://docs.anthropic.com/en/docs/claude-code) that provides intelligent automation and multi-agent orchestration capabilities for modern software development.", "metadata": { "source": { "provider": "github-claude-commands", "repository": "https://github.com/yangjrun/novellus", "path": ".claude/commands/README.md", "ref": "3ec1e3b58bf3e1502c295ba26ed6b8c1726a4f89", "url": "https://github.com/yangjrun/novellus/blob/3ec1e3b58bf3e1502c295ba26ed6b8c1726a4f89/.claude/commands/README.md", "key": "yangjrun/novellus/.claude/commands/README.md" } } }

About