A comprehensive production-ready system combining 84 specialized AI agents, 15 multi-agent workflow orchestrators, and 44 development tools organized into 62 focused, single-purpose plugins for Claude Code.

This unified repository provides everything needed for intelligent automation and multi-agent orchestration across modern software development:

• 62 Focused Plugins - Granular, single-purpose plugins optimized for minimal token usage and composability
• 84 Specialized Agents - Domain experts with deep knowledge across architecture, languages, infrastructure, quality, data/AI, documentation, business operations, and SEO
• 15 Workflow Orchestrators - Multi-agent coordination systems for complex operations like full-stack development, security hardening, ML pipelines, and incident response
• 44 Development Tools - Optimized utilities including project scaffolding, security scanning, test automation, and infrastructure setup

• Granular Plugin Architecture: 62 focused plugins optimized for minimal token usage
• Comprehensive Tooling: 44 development tools including test generation, scaffolding, and security scanning
• 100% Agent Coverage: All plugins include specialized agents
• Clear Organization: 23 categories with 1-6 plugins each for easy discovery
• Efficient Design: Average 3.4 components per plugin (follows Anthropic's 2-8 pattern)

Each plugin is completely isolated with its own agents and commands:

• Install only what you need - Each plugin loads only its specific agents and tools
• Minimal token usage - No unnecessary resources loaded into context
• Mix and match - Compose multiple plugins for complex workflows
• Clear boundaries - Each plugin has a single, focused purpose

Example: Installing python-development loads only 3 Python agents and 1 scaffolding tool (~300 tokens), not the entire marketplace.

Add this marketplace to Claude Code:

/plugin marketplace add wshobson/agents

This makes all 62 plugins available for installation, but does not load any agents or tools into your context.

Browse available plugins:

/plugin

Install only the plugins you need:

/plugin install python-development
/plugin install backend-development

Each installed plugin loads only its specific agents and commands into Claude's context.

💡 Getting Started? Install these popular plugins for immediate productivity gains.

code-documentation - Documentation and technical writing

/plugin install code-documentation

Automated doc generation, code explanation, and tutorial creation for comprehensive technical documentation.

debugging-toolkit - Smart debugging and developer experience

/plugin install debugging-toolkit

Interactive debugging, error analysis, and DX optimization for faster problem resolution.

git-pr-workflows - Git automation and PR enhancement

/plugin install git-pr-workflows

Git workflow automation, pull request enhancement, and team onboarding processes.

backend-development - Backend API design and architecture

/plugin install backend-development

RESTful and GraphQL API design with test-driven development and modern backend architecture patterns.

frontend-mobile-development - UI and mobile development

/plugin install frontend-mobile-development

React/React Native component development with automated scaffolding and cross-platform implementation.

full-stack-orchestration - End-to-end feature development

/plugin install full-stack-orchestration

Multi-agent coordination from backend → frontend → testing → security → deployment.

unit-testing - Automated test generation

/plugin install unit-testing

Generate pytest (Python) and Jest (JavaScript) unit tests automatically with comprehensive edge case coverage.

code-review-ai - AI-powered code review

/plugin install code-review-ai

Architectural analysis, security assessment, and code quality review with actionable feedback.

cloud-infrastructure - Cloud architecture design

/plugin install cloud-infrastructure

AWS/Azure/GCP architecture, Kubernetes setup, Terraform IaC, and multi-cloud cost optimization.

incident-response - Production incident management

/plugin install incident-response

Rapid incident triage, root cause analysis, and automated resolution workflows for production systems.

python-development - Python project scaffolding

/plugin install python-development

FastAPI/Django project initialization with modern tooling (uv, ruff) and production-ready architecture.

javascript-typescript - JavaScript/TypeScript scaffolding

/plugin install javascript-typescript

Next.js, React + Vite, and Node.js project setup with pnpm and TypeScript best practices.

📋 All 62 Plugins - Browse by category to find specialized plugins for your workflow.

claude-agents/
├── .claude-plugin/
│   └── marketplace.json          # Marketplace catalog (62 plugins)
├── plugins/                       # Isolated plugin directories
│   ├── python-development/
│   │   ├── agents/               # Python language agents
│   │   │   ├── python-pro.md
│   │   │   ├── django-pro.md
│   │   │   └── fastapi-pro.md
│   │   └── commands/             # Python tooling
│   │       └── python-scaffold.md
│   ├── backend-development/
│   │   ├── agents/
│   │   │   ├── backend-architect.md
│   │   │   ├── graphql-architect.md
│   │   │   └── tdd-orchestrator.md
│   │   └── commands/
│   │       └── feature-development.md
│   ├── security-scanning/
│   │   ├── agents/
│   │   │   └── security-auditor.md
│   │   └── commands/
│   │       ├── security-hardening.md
│   │       ├── security-sast.md
│   │       └── security-dependencies.md
│   └── ... (59 more isolated plugins)
└── README.md                      # This file

Each plugin contains:

• agents/ - Specialized agents for that domain
• commands/ - Tools and workflows specific to that plugin

After installing plugins, you can invoke their capabilities using slash commands - the primary interface for working with agents and workflows. Each plugin provides namespaced commands that you can run directly:

# List all available slash commands from installed plugins
/plugin

# Run a workflow command with arguments
/backend-development:feature-development user authentication with JWT

# Execute specialized tools
/unit-testing:test-generate src/auth/login.py

# Invoke security scans
/security-scanning:security-sast

Key benefits of slash commands:

• Direct invocation - No need to describe what you want in natural language
• Structured arguments - Pass parameters explicitly for precise control
• Composability - Chain commands together for complex workflows
• Discoverability - Use /plugin to see all available commands

Agents can also be invoked through natural language when you need Claude to reason about which specialist to use:

"Use backend-architect to design the authentication API"
"Have security-auditor scan for OWASP vulnerabilities"
"Get performance-engineer to optimize this database query"

Claude Code automatically selects and coordinates the appropriate agents based on your request.

Plugins provide pre-configured multi-agent workflows accessible via slash commands:

# Command-based workflow invocation
/full-stack-orchestration:full-stack-feature "user dashboard with real-time analytics"

# Natural language alternative
"Implement user dashboard with real-time analytics"

Orchestration: backend-architect → database-architect → frontend-developer → test-automator → security-auditor → deployment-engineer → observability-engineer

What happens:

1. Database schema design with migrations
2. Backend API implementation (REST/GraphQL)
3. Frontend components with state management
4. Comprehensive test suite (unit/integration/E2E)
5. Security audit and hardening
6. CI/CD pipeline setup with feature flags
7. Observability and monitoring configuration

# Comprehensive security assessment and remediation
/security-scanning:security-hardening --level comprehensive

# Natural language alternative
"Perform security audit and implement OWASP best practices"

Orchestration: security-auditor → backend-security-coder → frontend-security-coder → mobile-security-coder → test-automator

# ML feature development with production deployment
/machine-learning-ops:ml-pipeline "customer churn prediction model"

# Natural language alternative
"Build customer churn prediction model with deployment"

Orchestration: data-scientist → data-engineer → ml-engineer → mlops-engineer → performance-engineer

# Smart debugging with root cause analysis
/incident-response:smart-fix "production memory leak in payment service"

# Natural language alternative
"Debug production memory leak and create runbook"

Orchestration: incident-responder → devops-troubleshooter → debugger → error-detective → observability-engineer

Many slash commands support arguments for precise control:

# Test generation for specific files
/unit-testing:test-generate src/api/users.py

# Feature development with methodology specification
/backend-development:feature-development OAuth2 integration with social login

# Security dependency scanning
/security-scanning:security-dependencies

# Component scaffolding
/frontend-mobile-development:component-scaffold UserProfile component with hooks

# TDD workflow cycle
/tdd-workflows:tdd-red User can reset password
/tdd-workflows:tdd-green
/tdd-workflows:tdd-refactor

# Smart debugging
/debugging-toolkit:smart-debug memory leak in checkout flow

# Python project scaffolding
/python-development:python-scaffold fastapi-microservice

You can mix both approaches for optimal flexibility:

# Start with a command for structured workflow
/full-stack-orchestration:full-stack-feature "payment processing"

# Then provide natural language guidance
"Ensure PCI-DSS compliance and integrate with Stripe"
"Add retry logic for failed transactions"
"Set up fraud detection rules"

Use these commands to explore available functionality:

# List all installed plugins and their commands
/plugin

# Install a specific plugin
/plugin install python-development

# View available commands in a plugin
# After installation, commands will be listed with the format:
# /plugin-name:command-name

Development & Features:

• /backend-development:feature-development - End-to-end backend feature development
• /full-stack-orchestration:full-stack-feature - Complete full-stack feature implementation
• /multi-platform-apps:multi-platform - Cross-platform app development coordination

Testing & Quality:

• /unit-testing:test-generate - Generate comprehensive unit tests
• /tdd-workflows:tdd-cycle - Complete TDD red-green-refactor cycle
• /tdd-workflows:tdd-red - Write failing tests first
• /tdd-workflows:tdd-green - Implement code to pass tests
• /tdd-workflows:tdd-refactor - Refactor with passing tests

Code Quality & Review:

• /code-review-ai:ai-review - AI-powered code review
• /comprehensive-review:full-review - Multi-perspective analysis
• /comprehensive-review:pr-enhance - Enhance pull requests

Debugging & Troubleshooting:

• /debugging-toolkit:smart-debug - Interactive smart debugging
• /incident-response:incident-response - Production incident management
• /incident-response:smart-fix - Automated incident resolution
• /error-debugging:error-analysis - Deep error analysis
• /error-debugging:error-trace - Stack trace debugging
• /error-diagnostics:smart-debug - Smart diagnostic debugging
• /distributed-debugging:debug-trace - Distributed system tracing

Security:

• /security-scanning:security-hardening - Comprehensive security hardening
• /security-scanning:security-sast - Static application security testing
• /security-scanning:security-dependencies - Dependency vulnerability scanning
• /security-compliance:compliance-check - SOC2/HIPAA/GDPR compliance
• /frontend-mobile-security:xss-scan - XSS vulnerability scanning

Infrastructure & Deployment:

• /observability-monitoring:monitor-setup - Setup monitoring infrastructure
• /observability-monitoring:slo-implement - Implement SLO/SLI metrics
• /deployment-validation:config-validate - Pre-deployment validation
• /cicd-automation:workflow-automate - CI/CD pipeline automation

Data & ML:

• /machine-learning-ops:ml-pipeline - ML training pipeline orchestration
• /data-engineering:data-pipeline - ETL/ELT pipeline construction
• /data-engineering:data-driven-feature - Data-driven feature development

Documentation:

• /code-documentation:doc-generate - Generate comprehensive documentation
• /code-documentation:code-explain - Explain code functionality
• /documentation-generation:doc-generate - OpenAPI specs, diagrams, tutorials

Refactoring & Maintenance:

• /code-refactoring:refactor-clean - Code cleanup and refactoring
• /code-refactoring:tech-debt - Technical debt management
• /codebase-cleanup:deps-audit - Dependency auditing
• /codebase-cleanup:tech-debt - Technical debt reduction
• /framework-migration:legacy-modernize - Legacy code modernization
• /framework-migration:code-migrate - Framework migration
• /framework-migration:deps-upgrade - Dependency upgrades

Database:

• /database-migrations:sql-migrations - SQL migration automation
• /database-migrations:migration-observability - Migration monitoring
• /database-cloud-optimization:cost-optimize - Database and cloud optimization

Git & PR Workflows:

• /git-pr-workflows:pr-enhance - Enhance pull request quality
• /git-pr-workflows:onboard - Team onboarding automation
• /git-pr-workflows:git-workflow - Git workflow automation

Project Scaffolding:

• /python-development:python-scaffold - FastAPI/Django project setup
• /javascript-typescript:typescript-scaffold - Next.js/React + Vite setup
• /systems-programming:rust-project - Rust project scaffolding

AI & LLM Development:

• /llm-application-dev:langchain-agent - LangChain agent development
• /llm-application-dev:ai-assistant - AI assistant implementation
• /llm-application-dev:prompt-optimize - Prompt engineering optimization
• /agent-orchestration:multi-agent-optimize - Multi-agent optimization
• /agent-orchestration:improve-agent - Agent improvement workflows

Testing & Performance:

• /performance-testing-review:ai-review - Performance analysis
• /application-performance:performance-optimization - App optimization

Team Collaboration:

• /team-collaboration:issue - Issue management automation
• /team-collaboration:standup-notes - Standup notes generation

Accessibility:

• /accessibility-compliance:accessibility-audit - WCAG compliance auditing

API Development:

• /api-testing-observability:api-mock - API mocking and testing

Context Management:

• /context-management:context-save - Save conversation context
• /context-management:context-restore - Restore previous context

Agents are assigned to specific Claude models based on task complexity and computational requirements. The system uses three model tiers:

This marketplace follows industry best practices with a focus on granularity, composability, and minimal token usage:

• Each plugin does one thing well (Unix philosophy)
• Clear, focused purposes (describable in 5-10 words)
• Average plugin size: 3.4 components (follows Anthropic's 2-8 pattern)
• Zero bloated plugins - all plugins focused and purposeful

• 62 focused plugins optimized for specific use cases
• 23 clear categories with 1-6 plugins each for easy discovery
• Organized by domain:
  • Development: 4 plugins (debugging, backend, frontend, multi-platform)
  • Security: 4 plugins (scanning, compliance, backend-api, frontend-mobile)
  • Operations: 4 plugins (incident, diagnostics, distributed, observability)
  • Languages: 6 plugins (Python, JS/TS, systems, JVM, scripting, functional)
  • Infrastructure: 5 plugins (deployment, validation, K8s, cloud, CI/CD)
  • And 18 more specialized categories

• 44 development tools including:
  • test-generate.md - Automated unit test generation (pytest/Jest)
  • component-scaffold.md - React/React Native scaffolding
  • xss-scan.md - XSS vulnerability scanner with secure patterns
  • python-scaffold.md - Python project scaffolding (FastAPI/Django)
  • typescript-scaffold.md - TypeScript project scaffolding (Next.js/Vite)
  • rust-project.md - Rust project scaffolding (cargo/Axum)
• 100% agent coverage - all plugins include at least one agent
• Language-specific plugins - 6 dedicated plugins for language experts

• Optimized token usage - isolated plugins load only what you need
• Better context efficiency - granular plugins reduce unnecessary context
• Clear discoverability - well-organized categories and focused purposes
• Isolated dependencies - each plugin contains only its required resources
• 100% component coverage - all 84 agents available across plugins

Composability Over Bundling

• Mix and match plugins based on needs
• Workflow orchestrators compose focused plugins
• No forced feature bundling

Context Efficiency

• Smaller tools = faster processing
• Better fit in LLM context windows
• More accurate, focused responses

Maintainability

• Single-purpose = easier updates
• Clear boundaries = isolated changes
• Less duplication = simpler maintenance

Discoverability

• Clear plugin names convey purpose
• Logical categorization
• Easy to find the right tool

To add new agents or commands:

1. Identify or create the appropriate plugin directory in plugins/
2. Create a new .md file in plugins/{plugin-name}/agents/ or plugins/{plugin-name}/commands/
3. Use lowercase, hyphen-separated naming convention
4. Write clear activation criteria in the description
5. Define comprehensive system prompt with expertise areas
6. Update the plugin definition in .claude-plugin/marketplace.json

Each plugin must follow this structure:

plugins/{plugin-name}/
├── agents/          # Agent definitions (optional)
│   └── agent-name.md
└── commands/        # Commands/tools (optional)
    └── command-name.md

Each subagent is defined as a Markdown file with frontmatter:

---
name: subagent-name
description: Activation criteria for this subagent
model: haiku|sonnet|opus # Optional: Model selection
tools: tool1, tool2 # Optional: Tool restrictions
---

System prompt defining the subagent's expertise and behavior

• haiku: Simple, deterministic tasks with minimal reasoning
• sonnet: Standard development and engineering tasks
• opus: Complex analysis, architecture, and critical operations

MIT License - see LICENSE file for details.

• Claude Code Documentation
• Claude Code Plugins Guide
• Claude Code Subagents Guide
• Claude Code Slash Commands Reference
• Claude Code GitHub