Agents (wshobson/agents)

Agents

https://github.com/wshobson/agents
Admin
A collection of 56 specialized AI subagents designed to extend Claude Code's capabilities, offering...

Tokens:1,156,547
Snippets:5,943
Trust Score:9.5
Update:3 weeks ago
Show doc for...
Context Summary (auto-generated)
Raw
# Claude Code Plugins: Orchestration and Automation

Claude Code Plugins is a comprehensive production-ready system for intelligent automation and multi-agent orchestration across modern software development. It provides **72 focused, single-purpose plugins** containing **112 specialized AI agents**, **146 agent skills**, and **79 development tools** that extend Claude Code's capabilities. The plugin architecture follows a granular design philosophy—install only what you need, with minimal token usage and maximum composability.

The system operates on two primary interfaces: slash commands for direct tool invocation and natural language for automatic agent selection. Plugins bundle domain-specific agents, commands, and skills together, allowing teams to compose complex workflows while maintaining clear boundaries. The three-tier model strategy (Opus for critical architecture/security, Sonnet for complex tasks, Haiku for fast operations) optimizes both performance and cost across different use cases.

---

## Marketplace Setup

Add the plugin marketplace to make all 72 plugins available for installation.

```bash
# Add the marketplace to Claude Code
/plugin marketplace add wshobson/agents

# Browse available plugins
/plugin

# Install specific plugins
/plugin install python-development
/plugin install backend-development
/plugin install kubernetes-operations
```

---

## Full-Stack Feature Development

Coordinate 7+ agents for complete feature implementation from backend to deployment.

The `full-stack-orchestration` plugin provides end-to-end feature development by coordinating backend-architect, database-architect, frontend-developer, test-automator, security-auditor, deployment-engineer, and observability-engineer agents in sequence.

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

# What happens automatically:
# 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

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

# Combine with additional guidance
/full-stack-orchestration:full-stack-feature "payment processing"
# Then follow up with natural language
"Ensure PCI-DSS compliance and integrate with Stripe"
"Add retry logic for failed transactions"
```

---

## Python Project Scaffolding

Create production-ready Python projects with modern tooling using the python-development plugin.

This command generates complete project structures with uv package manager, FastAPI/Django frameworks, type hints, pytest testing setup, and ruff linting configuration following current best practices.

```bash
# Scaffold a FastAPI microservice
/python-development:python-scaffold fastapi-microservice

# Generated project structure:
# fastapi-project/
# ├── pyproject.toml
# ├── README.md
# ├── .env.example
# ├── Makefile
# ├── src/
# │   └── project_name/
# │       ├── main.py
# │       ├── config.py
# │       ├── api/v1/endpoints/
# │       ├── core/
# │       ├── models/
# │       ├── schemas/
# │       └── services/
# └── tests/
#     ├── conftest.py
#     └── api/

# Development commands from generated Makefile:
make install    # uv sync
make dev        # uv run uvicorn src.project_name.main:app --reload
make test       # uv run pytest -v
make lint       # uv run ruff check .
make format     # uv run ruff format .

# Skills automatically activated:
# - async-python-patterns: AsyncIO and concurrency
# - python-testing-patterns: pytest and fixtures
# - uv-package-manager: Fast dependency management
```

---

## Security Hardening

Multi-agent security assessment with SAST, dependency scanning, and code review.

The security-scanning plugin coordinates security-auditor, backend-security-coder, frontend-security-coder, mobile-security-coder, and test-automator agents for comprehensive security hardening.

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

# Individual security operations
/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

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

# Skills activated for threat modeling:
# - stride-analysis-patterns: STRIDE threat identification
# - attack-tree-construction: Threat scenario mapping
# - sast-configuration: Static analysis tool setup
# - threat-mitigation-mapping: Prioritized remediation
```

---

## Test-Driven Development Workflow

Execute TDD red-green-refactor cycles with structured commands.

The tdd-workflows plugin provides systematic test-driven development methodology with explicit phase commands and verification checkpoints.

```bash
# Complete TDD cycle
/tdd-workflows:tdd-cycle user authentication

# Or run individual phases
/tdd-workflows:tdd-red "User can reset password"      # Write failing tests first
/tdd-workflows:tdd-green                               # Implement code to pass tests
/tdd-workflows:tdd-refactor                            # Refactor with passing tests

# Generate comprehensive unit tests for existing code
/unit-testing:test-generate src/api/users.py

# Multi-perspective code review after implementation
/comprehensive-review:full-review

# Skills integrated:
# - python-testing-patterns: pytest fixtures and mocking
# - javascript-testing-patterns: Jest/Vitest patterns
# - e2e-testing-patterns: Playwright/Cypress for E2E
```

---

## Kubernetes Deployment

Create production-ready Kubernetes manifests with Helm charts and GitOps workflows.

The kubernetes-operations plugin provides the kubernetes-architect agent with 4 specialized skills for cloud-native infrastructure deployment.

```bash
# Deploy with Kubernetes
/kubernetes-operations:deploy production

# Natural language request activates skills automatically
"Create production Kubernetes deployment with Helm chart and GitOps"

# Skills activated:
# - k8s-manifest-generator: Production-ready Deployments, Services, ConfigMaps
# - helm-chart-scaffolding: Helm chart design and organization
# - gitops-workflow: ArgoCD/Flux declarative deployments
# - k8s-security-policies: NetworkPolicy, PodSecurityPolicy, RBAC

# Example Helm chart structure generated:
# charts/
# └── app-name/
#     ├── Chart.yaml
#     ├── values.yaml
#     ├── templates/
#     │   ├── deployment.yaml
#     │   ├── service.yaml
#     │   ├── configmap.yaml
#     │   ├── ingress.yaml
#     │   └── _helpers.tpl
#     └── values/
#         ├── staging.yaml
#         └── production.yaml
```

---

## Multi-Agent Team Orchestration

Spawn parallel agent teams for code review, debugging, and feature development.

The agent-teams plugin enables experimental multi-agent workflows with presets for common team configurations.

```bash
# Prerequisites: Enable experimental feature
export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

# Configure teammate display mode in ~/.claude/settings.json
# { "teammateMode": "tmux" }

# Install the plugin
/plugin install agent-teams@claude-code-workflows

# Multi-Reviewer Code Review
/team-review src/ --reviewers security,performance,architecture
# Spawns 3 reviewers analyzing from their assigned dimension
# Consolidates findings into prioritized report

# Hypothesis-Driven Debugging
/team-debug "API returns 500 on POST /users with valid payload" --hypotheses 3
# Generates 3 competing hypotheses
# Spawns investigators for each
# Presents most likely root cause with fix

# Parallel Feature Development
/team-feature "Add user authentication with OAuth2" --team-size 3 --plan-first
# Decomposes feature into work streams with file ownership
# Gets approval, then spawns implementers

# Security Audit Team
/team-spawn security
# 4 reviewers: OWASP, auth/access, dependencies, secrets/config

# Team Management
/team-status           # Display members, tasks, progress
/team-shutdown         # Graceful cleanup
/team-delegate --rebalance  # Workload balancing
```

---

## Conductor: Context-Driven Development

Transform Claude Code into a project management tool with structured workflows.

The conductor plugin enforces a **Context -> Spec & Plan -> Implement** workflow, maintaining product vision, technical decisions, and work units as structured artifacts.

```bash
# Install conductor
/plugin install conductor

# Initialize project with interactive setup
/conductor:setup
# Creates: product.md, tech-stack.md, workflow.md, code_styleguides/

# Create a new feature track
/conductor:new-track
# Interactive Q&A gathers requirements
# Generates: spec.md and plan.md with phased tasks

# Execute the implementation plan
/conductor:implement
# Follows TDD workflow with verification checkpoints
# Updates task status markers automatically

# Monitor progress
/conductor:status
# Shows current phase, task, completion percentage, blockers

# Git-aware revert by logical unit
/conductor:revert
# Select track, phase, or task to undo

# Manage track lifecycle
/conductor:manage
# Archive, restore, delete, rename tracks

# Generated artifact structure:
# conductor/
# ├── index.md              # Navigation hub
# ├── product.md            # Product vision & goals
# ├── tech-stack.md         # Technology preferences
# ├── workflow.md           # Development practices
# ├── tracks.md             # Master track registry
# └── tracks/
#     └── <track-id>/
#         ├── spec.md       # Requirements specification
#         └── plan.md       # Phased task breakdown
```

---

## C4 Architecture Documentation

Generate comprehensive C4 architecture documentation with bottom-up analysis.

The c4-architecture plugin coordinates four agents (c4-code, c4-component, c4-container, c4-context) to create complete architecture documentation with Mermaid diagrams.

```bash
# Generate C4 documentation
/c4-architecture:c4-architecture

# Orchestration flow:
# 1. c4-code (haiku): Bottom-up analysis of all subdirectories
#    - Function signatures and dependencies
# 2. c4-component (sonnet): Synthesizes into logical components
#    - Interfaces and relationships
# 3. c4-container (sonnet): Maps to deployment containers
#    - OpenAPI/Swagger API specifications
# 4. c4-context (sonnet): Creates system context
#    - Personas, user journeys, external dependencies

# Output structure:
# C4-Documentation/
# ├── context.md           # System context with Mermaid diagram
# ├── containers.md        # Container architecture
# ├── components/
# │   └── *.md             # Component documentation
# └── code/
#     └── *.md             # Code-level documentation

# Natural language alternative
"Create C4 architecture documentation for this codebase"
```

---

## Incident Response and Debugging

Smart debugging with root cause analysis and automated incident resolution.

The incident-response and debugging plugins coordinate incident-responder, devops-troubleshooter, debugger, error-detective, and observability-engineer agents.

```bash
# Smart incident resolution
/incident-response:smart-fix "production memory leak in payment service"
# Orchestrates: incident-responder → devops-troubleshooter → debugger
#              → error-detective → observability-engineer

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

# Error analysis and tracing
/error-debugging:error-analysis
/error-debugging:error-trace

# Distributed system tracing
/distributed-debugging:debug-trace

# Skills for incident response:
# - postmortem-writing: Blameless postmortems with RCA
# - incident-runbook-templates: Common scenario runbooks
# - on-call-handoff-patterns: Context preservation

# Natural language alternatives
"Debug production memory leak and create runbook"
"Trace the error through our microservices"
```

---

## LLM Application Development

Build LLM applications with LangChain, RAG systems, and prompt engineering.

The llm-application-dev plugin provides 8 specialized skills for AI application development including vector databases, embeddings, and evaluation strategies.

```bash
# LangChain agent development
/llm-application-dev:langchain-agent

# AI assistant implementation
/llm-application-dev:ai-assistant

# Prompt engineering optimization
/llm-application-dev:prompt-optimize

# Multi-agent system optimization
/agent-orchestration:multi-agent-optimize
/agent-orchestration:improve-agent

# Skills automatically activated:
# - langchain-architecture: Agents, memory, tool integration
# - prompt-engineering-patterns: Advanced prompt techniques
# - rag-implementation: Retrieval-Augmented Generation
# - llm-evaluation: Automated metrics and benchmarking
# - embedding-strategies: Text/image embedding pipelines
# - similarity-search-patterns: ANN algorithms, distance metrics
# - vector-index-tuning: HNSW, IVF configurations
# - hybrid-search-implementation: Vector + keyword search

# Natural language usage
"Build a RAG system for document Q&A"
# Activates: rag-implementation, prompt-engineering-patterns
```

---

## ML Pipeline Orchestration

Build end-to-end machine learning pipelines with production deployment.

The machine-learning-ops plugin coordinates data-scientist, data-engineer, ml-engineer, mlops-engineer, and performance-engineer agents.

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

# Data pipeline construction
/data-engineering:data-pipeline
/data-engineering:data-driven-feature

# Skills integrated:
# - ml-pipeline-workflow: End-to-end MLOps pipelines
# - spark-optimization: Partitioning, caching, broadcast joins
# - dbt-transformation-patterns: Incremental strategies
# - airflow-dag-patterns: DAG dependencies and error handling
# - data-quality-frameworks: Great Expectations validation

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

---

## CI/CD Pipeline Automation

Configure CI/CD pipelines with GitHub Actions, GitLab CI, and secrets management.

The cicd-automation plugin provides deployment-pipeline-design, github-actions-templates, gitlab-ci-patterns, and secrets-management skills.

```bash
# Automate CI/CD workflow
/cicd-automation:workflow-automate

# Pre-deployment validation
/deployment-validation:config-validate

# Monitoring setup
/observability-monitoring:monitor-setup
/observability-monitoring:slo-implement

# Skills activated:
# - deployment-pipeline-design: Multi-stage pipelines with approval gates
# - github-actions-templates: Production-ready GHA workflows
# - gitlab-ci-patterns: Multi-stage GitLab CI/CD
# - secrets-management: Vault, AWS Secrets Manager integration

# Example GitHub Actions workflow generated:
# .github/workflows/ci.yml
# - Build, test, lint stages
# - Security scanning
# - Docker image building
# - Deployment with approval gates
```

---

## Agent Invocation Patterns

Agents can be invoked through natural language or slash commands.

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

# Slash command invocation
/backend-development:feature-development user authentication
/security-scanning:security-sast
/incident-response:smart-fix "memory leak in payment service"

# Workflow composition - chain multiple plugins
/backend-development:feature-development payment processing API
/security-scanning:security-hardening
/unit-testing:test-generate
/comprehensive-review:full-review
/cicd-automation:workflow-automate
/observability-monitoring:monitor-setup

# Hybrid orchestration pattern (Sonnet → Haiku)
# Sonnet: backend-architect (design API architecture)
#    ↓
# Haiku: Generate API endpoints following spec
#    ↓
# Haiku: test-automator (generate tests)
#    ↓
# Sonnet: code-reviewer (architectural review)
```

---

## Summary

Claude Code Plugins addresses the full software development lifecycle through specialized, composable agents and skills. Core use cases include: full-stack feature development with multi-agent coordination, production-grade Python/JavaScript project scaffolding, comprehensive security auditing with SAST and dependency scanning, test-driven development workflows, Kubernetes deployment with GitOps, LLM application development with RAG systems, ML pipeline orchestration, and incident response automation. The granular plugin architecture ensures minimal token usage while enabling complex workflow composition.

Integration follows a straightforward pattern: add the marketplace, install domain-specific plugins, then invoke capabilities through slash commands or natural language. The three-tier model strategy (Opus/Sonnet/Haiku) optimizes for both task complexity and cost efficiency. Skills provide progressive disclosure—loading specialized knowledge only when activated by context. For team workflows, the experimental Agent Teams feature enables parallel code review, hypothesis-driven debugging, and coordinated feature development with file ownership boundaries. The Conductor plugin transforms Claude Code into a project management tool with persistent context and structured implementation plans.