agents Documentation

1. Project Overview & Quickstart (wshobson/agents) Copy Chapter

File: README.md Copy Chapter

Agentic Plugin Marketplace

Production-ready agentic workflow building blocks: 92 plugins, 202 agents,
181 skills, 105 commands — built for Claude Code and consumed natively by
OpenAI Codex CLI, Cursor, OpenCode, the Antigravity CLI, and GitHub Copilot from a single Markdown source.

[!NOTE]
One source-of-truth (plugins/), five harnesses. Each harness gets idiomatic,
harness-native artifacts — not lowest-common-denominator translations.
See docs/harnesses.md for the capability matrix.

Quick start Copy Chapter

Pick your harness:

Claude Code Copy Section

/plugin marketplace add wshobson/agents
/plugin install python-development          # or any of 92 plugins

→ Full Claude Code setup, troubleshooting, and plugin catalog

Codex CLI · Cursor · OpenCode · Antigravity CLI · Copilot Copy Section

Codex and Cursor install natively from the committed registries (which point at the source plugins/):

npx codex-marketplace add wshobson/agents        # Codex; then install individual plugins
# Cursor: add the marketplace, then `/plugin install <name>` (reads .cursor-plugin/ + source)

Antigravity and OpenCode install via clone + generate (the transformed trees are gitignored):

gh repo clone wshobson/agents ~/agents && cd ~/agents
make generate HARNESS=antigravity && make install-antigravity  # Antigravity (agy)
make install-opencode                                          # OpenCode (runs generate + symlinks)

Setup details and per-harness gotchas: docs/harnesses.md.

What's inside Copy Chapter

Browse the catalog: docs/plugins.md · docs/agents.md · docs/agent-skills.md

How it works Copy Chapter

Each plugin is isolated and composable: agents, commands, and skills are auto-discovered
from directory structure. Installing a plugin loads only its components into
context — not the whole marketplace.

plugins/python-development/
├── .claude-plugin/plugin.json
├── agents/             # 3 Python agents (python-pro, django-pro, fastapi-pro)
├── commands/           # 1 scaffolding command
└── skills/             # 16 specialized skills (async, testing, packaging, …)

Tiered model strategy:

→ Model configuration details

Multi-harness support Copy Chapter

This marketplace ships to five agentic harnesses from one Markdown source. Each adapter
emits harness-native artifacts (not lowest-common-denominator translations):

make generate-all                        # all five
make validate                            # structural checks
make garden                              # drift / dead-link / cap detection

Codex and Cursor install from source via committed registries; Antigravity and OpenCode install via clone + make.

→ Full capability matrix and per-harness deep-dives

Quality evaluation Copy Chapter

plugin-eval is a three-layer evaluation framework for measuring
and certifying plugin/skill quality:

• Static — deterministic structural analysis (<2s, free)
• LLM Judge — semantic evaluation across 4 dimensions (~30s, Haiku + Sonnet)
• Monte Carlo — statistical reliability via 50-100 simulated runs (~2-5 min)

uv run plugin-eval score path/to/skill --depth quick
uv run plugin-eval certify path/to/skill

→ PluginEval framework documentation

Documentation map Copy Chapter

Detail lives in docs/. Read in this order:

• docs/plugins.md — full catalog of all 92 plugins
• docs/agents.md — all 202 agents by category
• docs/agent-skills.md — 181 skills with progressive disclosure
• docs/usage.md — commands, workflows, examples
• docs/architecture.md — design principles
• docs/harnesses.md — cross-harness capability matrix
• docs/authoring.md — portable-content style guide
• docs/plugin-eval.md — quality evaluation framework
• docs/round-trip-results.md — real-CLI verification recipes

Harness setup, capability deltas, and gotchas live in docs/harnesses.md.

Contributing: CONTRIBUTING.md · Authoring: docs/authoring.md

External Memory Integration Copy Chapter

Pensyve is included as an external
git-subdir entry for Claude Code. Pensyve also maintains direct upstream
integrations for Codex CLI, Cursor, OpenCode, and Copilot (not yet Antigravity CLI).

License Copy Chapter

MIT — see LICENSE.

Star history Copy Chapter

File: docs/agent-skills.md Copy Chapter

Agent Skills

Agent Skills are modular packages that extend Claude's capabilities with specialized domain knowledge, following Anthropic's Agent Skills Specification. This plugin ecosystem includes 181 local specialized skills across 50 plugins, enabling progressive disclosure and efficient token usage.

Overview Copy Chapter

Skills provide Claude with deep expertise in specific domains without loading everything into context upfront. Each skill includes:

• YAML Frontmatter: Name and activation criteria
• Progressive Disclosure: Metadata → Instructions → Resources
• Activation Triggers: Clear "Use when" clauses for automatic invocation

Skills by Plugin Copy Chapter

Kubernetes Operations (4 skills) Copy Section

LLM Application Development (8 skills) Copy Section

Backend Development (9 skills) Copy Section

Developer Essentials (11 skills) Copy Section

Blockchain & Web3 (4 skills) Copy Section

CI/CD Automation (4 skills) Copy Section

Cloud Infrastructure (8 skills) Copy Section

Framework Migration (4 skills) Copy Section

Observability & Monitoring (4 skills) Copy Section

Payment Processing (4 skills) Copy Section

Python Development (16 skills) Copy Section

JavaScript/TypeScript (4 skills) Copy Section

API Scaffolding (1 skill) Copy Section

Machine Learning Operations (1 skill) Copy Section

Security Scanning (5 skills) Copy Section

Accessibility Compliance (2 skills) Copy Section

Business Analytics (2 skills) Copy Section

Before You Build (1 skill) Copy Section

Avoid AI Writing (1 skill) Copy Section

Data Engineering (4 skills) Copy Section

Documentation Generation (3 skills) Copy Section

Frontend Mobile Development (4 skills) Copy Section

UI Design (9 skills) Copy Section

Game Development (2 skills) Copy Section

HR Legal Compliance (2 skills) Copy Section

Incident Response (3 skills) Copy Section

Quantitative Trading (2 skills) Copy Section

Systems Programming (3 skills) Copy Section

Conductor - Project Management (3 skills) Copy Section

Agent Teams (6 skills) Copy Section

Reverse Engineering (4 skills) Copy Section

Startup Business Analyst (5 skills) Copy Section

Shell Scripting (3 skills) Copy Section

Database Design (1 skill) Copy Section

Documentation Standards (1 skill) Copy Section

.NET Contribution (1 skill) Copy Section

Plugin Eval (1 skill) Copy Section

Block No-Verify (1 skill) Copy Section

Protect MCP (1 skill) Copy Section

Social Publishing (1 skill) Copy Section

LLM Fine-Tuning (10 skills) Copy Section

PPTX Deck Creation (5 skills) Copy Section

DGX Spark Ops (3 skills) Copy Section

How Skills Work Copy Chapter

Activation Copy Section

Skills are automatically activated when Claude detects matching patterns in your request:

User: "Set up Kubernetes deployment with Helm chart"
→ Activates: helm-chart-scaffolding, k8s-manifest-generator

User: "Build a RAG system for document Q&A"
→ Activates: rag-implementation, prompt-engineering-patterns

User: "Optimize Python async performance"
→ Activates: async-python-patterns, python-performance-optimization

Progressive Disclosure Copy Section

Skills use a three-tier architecture for token efficiency:

1. Metadata (Frontmatter): Name and activation criteria (always loaded)
2. Instructions: Core guidance and patterns (loaded when activated)
3. Resources: Examples and templates (loaded on demand)

Integration with Agents Copy Section

Skills work alongside agents to provide deep domain expertise:

• Agents: High-level reasoning and orchestration
• Skills: Specialized knowledge and implementation patterns

Example workflow:

backend-architect agent → Plans API architecture
  ↓
api-design-principles skill → Provides REST/GraphQL best practices
  ↓
fastapi-templates skill → Supplies production-ready templates

Specification Compliance Copy Chapter

All 181 skills follow the Agent Skills Specification:

• ✓ Required name field (hyphen-case)
• ✓ Required description field with "Use when" clause
• ✓ Descriptions under 1024 characters
• ✓ Complete, non-truncated descriptions
• ✓ Proper YAML frontmatter formatting

Creating New Skills Copy Chapter

To add a skill to a plugin:

1. Create plugins/{plugin-name}/skills/{skill-name}/SKILL.md

2. Add YAML frontmatter:

   yaml Copy

   ---
   name: skill-name
   ---

3. Write comprehensive skill content using progressive disclosure

4. Add skill path to marketplace.json:

   json Copy

   {
     "name": "plugin-name",
     "skills": ["./skills/skill-name"]
   }

Skill Structure Copy Section

plugins/{plugin-name}/
└── skills/
    └── {skill-name}/
        └── SKILL.md        # Frontmatter + content

Benefits Copy Chapter

• Token Efficiency: Load only relevant knowledge when needed
• Specialized Expertise: Deep domain knowledge without bloat
• Clear Activation: Explicit triggers prevent unwanted invocation
• Composability: Mix and match skills across workflows
• Maintainability: Isolated updates don't affect other skills

Resources Copy Chapter

• Anthropic Skills Repository
• Agent Skills Documentation

File: docs/agents.md Copy Chapter

Agent Reference

Complete reference for all 202 local specialized AI agents organized by category with model assignments.

Agent Categories Copy Chapter

Architecture & System Design Copy Section

Core Architecture

UI/UX & Mobile

Programming Languages Copy Section

Systems & Low-Level

Web & Application

Enterprise & JVM

Specialized Platforms

Infrastructure & Operations Copy Section

DevOps & Deployment

Database Management

Incident Response & Network

Project Management

Quality Assurance & Security Copy Section

Code Quality & Review

Testing & Debugging

Performance & Observability

Data & AI Copy Section

Data Engineering & Analytics

Machine Learning & AI

Documentation & Technical Writing Copy Section

Business & Operations Copy Section

Business Analysis & Finance

Marketing & Sales

Support & Legal

SEO & Content Optimization Copy Section

Specialized Domains Copy Section

Model Configuration Copy Chapter

Agents are assigned to specific Claude models based on task complexity and computational requirements.

Model Distribution Summary Copy Section

Model Selection Criteria Copy Section

Haiku - Fast Execution & Deterministic Tasks

Use when:

• Generating code from well-defined specifications
• Creating tests following established patterns
• Writing documentation with clear templates
• Executing infrastructure operations
• Performing database query optimization
• Handling customer support responses
• Processing SEO optimization tasks
• Managing deployment pipelines

Sonnet - Complex Reasoning & Architecture

Use when:

• Designing system architecture
• Making technology selection decisions
• Performing security audits
• Reviewing code for architectural patterns
• Creating complex AI/ML pipelines
• Providing language-specific expertise
• Orchestrating multi-agent workflows
• Handling business-critical legal/HR matters

Fable - Longest-Horizon Autonomous Work

Claude Fable 5 (model: fable) is the tier above Opus. It is opt-in in Claude Code
(v2.1.170+, never the default) and carries roughly 2.6× the effective cost of Opus
($10/$50 per MTok plus a ~30% heavier tokenizer), so reserve it for agents where Opus
demonstrably needs multiple attempts.

Use when:

• Running multi-hour autonomous sessions (large codebase migrations, overnight refactors)
• Executing end-to-end work from a single well-specified goal
• Coordinating long-lived parallel sub-agent workstreams

Avoid for:

• Security-analysis agents — Fable 5's cyber/bio safety classifiers fall back to
  Opus 4.8 on that content anyway
• Anything Sonnet or Opus already completes in one pass

Other harnesses map fable to their top available model (see
authoring.md). Fable-tier agent bodies should state goals
and constraints rather than step-by-step scaffolding, and must not ask the model to echo
its internal reasoning.

Hybrid Orchestration Patterns Copy Section

The plugin ecosystem leverages Sonnet + Haiku orchestration for optimal performance and cost efficiency:

Pattern 1: Planning → Execution

Sonnet: backend-architect (design API architecture)
  ↓
Haiku: Generate API endpoints following spec
  ↓
Haiku: test-automator (generate comprehensive tests)
  ↓
Sonnet: code-reviewer (architectural review)

Pattern 2: Reasoning → Action (Incident Response)

Sonnet: incident-responder (diagnose issue, create strategy)
  ↓
Haiku: devops-troubleshooter (execute fixes)
  ↓
Haiku: deployment-engineer (deploy hotfix)
  ↓
Haiku: Implement monitoring alerts

Pattern 3: Complex → Simple (Database Design)

Sonnet: database-architect (schema design, technology selection)
  ↓
Haiku: sql-pro (generate migration scripts)
  ↓
Haiku: database-admin (execute migrations)
  ↓
Haiku: database-optimizer (tune query performance)

Pattern 4: Multi-Agent Workflows

Full-Stack Feature Development:
Sonnet: backend-architect + frontend-developer (design components)
  ↓
Haiku: Generate code following designs
  ↓
Haiku: test-automator (unit + integration tests)
  ↓
Sonnet: security-auditor (security review)
  ↓
Haiku: deployment-engineer (CI/CD setup)
  ↓
Haiku: Setup observability stack

Agent Invocation Copy Chapter

Natural Language Copy Section

Agents can 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"

Slash Commands Copy Section

Many agents are accessible through plugin slash commands for direct invocation:

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

Contributing Copy Chapter

To add a new agent:

1. Create plugins/{plugin-name}/agents/{agent-name}.md
2. Add frontmatter with name, description, and model assignment
3. Write comprehensive system prompt
4. Update plugin definition in .claude-plugin/marketplace.json

See Contributing Guide for details.

File: docs/architecture.md Copy Chapter

Architecture & Design Principles

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

Core Philosophy Copy Chapter

Single Responsibility Principle Copy Section

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

Composability Over Bundling Copy Section

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

Context Efficiency Copy Section

• Smaller tools = faster processing
• Better fit in LLM context windows
• More accurate, focused responses
• Install only what you need

Maintainability Copy Section

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

Granular Plugin Architecture Copy Chapter

Plugin Distribution Copy Section

• 92 marketplace plugins (91 local + 1 external via git-subdir) optimized for specific use cases
• 26 clear categories with 1-10 plugins each for easy discovery
• Organized by domain:
  • Development: 6 plugins (debugging, backend, frontend, UI, multi-platform, essentials)
  • Security: 6 plugins (scanning, compliance, API, frontend/mobile, reverse engineering, hook policy)
  • Operations: 4 plugins (incident, diagnostics, distributed, observability)
  • Languages: 10 plugins (Python, JS/TS, systems, JVM, scripting, functional, embedded, and more)
  • Infrastructure: 5 plugins (deployment, validation, K8s, cloud, CI/CD)
  • And 21 more specialized categories

Component Breakdown Copy Section

202 Local Specialized Agents

• Domain experts with deep knowledge
• Organized across architecture, languages, infrastructure, quality, data/AI, documentation, business, and SEO
• Model-optimized with a five-tier strategy (Fable, Opus, Sonnet, Haiku, Inherit) for performance and cost

16 Workflow Orchestrators

• Multi-agent coordination systems
• Complex operations like full-stack development, security hardening, ML pipelines, incident response
• Pre-configured agent workflows

105 Local Commands

• Optimized utilities including:
  • Project scaffolding (Python, TypeScript, Rust)
  • Security scanning (SAST, dependency audit, XSS)
  • Test generation (pytest, Jest)
  • Component scaffolding (React, React Native)
  • Infrastructure setup (Terraform, Kubernetes)

181 Local Agent Skills

• Modular knowledge packages
• Progressive disclosure architecture
• Domain-specific expertise across 49 plugins
• Spec-compliant (Anthropic Agent Skills Specification)

Repository Structure Copy Chapter

/* Detailed source-code truncated for AI context efficiency. */

Plugin Structure Copy Chapter

Each plugin contains:

• agents/ - Specialized agents for that domain (optional)
• commands/ - Tools and workflows specific to that plugin (optional)
• skills/ - Modular knowledge packages with progressive disclosure (optional)

Minimum Requirements Copy Section

• At least one agent, command, OR skill
• Clear, focused purpose
• Proper frontmatter in all files
• Entry in marketplace.json

Example Plugin Copy Section

plugins/kubernetes-operations/
├── agents/
│   └── kubernetes-architect.md   # K8s architecture and design
├── commands/
│   └── k8s-deploy.md            # Deployment automation
└── skills/
    ├── k8s-manifest-generator/   # Manifest creation skill
    ├── helm-chart-scaffolding/   # Helm chart skill
    ├── gitops-workflow/          # GitOps automation skill
    └── k8s-security-policies/    # Security policy skill

Agent Skills Architecture Copy Chapter

Progressive Disclosure Copy Section

Skills use a three-tier architecture for token efficiency:

1. Metadata (Frontmatter): Name and activation criteria (always loaded)
2. Instructions: Core guidance and patterns (loaded when activated)
3. Resources: Examples and templates (loaded on demand)

Specification Compliance Copy Section

All skills follow the Agent Skills Specification:

---
name: skill-name # Required: hyphen-case
---
# Skill content with progressive disclosure

Benefits Copy Section

• Token Efficiency: Load only relevant knowledge when needed
• Specialized Expertise: Deep domain knowledge without bloat
• Clear Activation: Explicit triggers prevent unwanted invocation
• Composability: Mix and match skills across workflows
• Maintainability: Isolated updates don't affect other skills

See Agent Skills for complete details on the 181 skills.

Model Configuration Strategy Copy Chapter

Five-Tier Architecture Copy Section

The system uses Claude Fable, Opus, Sonnet, Haiku, and Inherit assignments strategically:

Selection Criteria Copy Section

Haiku - Fast Execution & Deterministic Tasks

• Generating code from well-defined specifications
• Creating tests following established patterns
• Writing documentation with clear templates
• Executing infrastructure operations
• Performing database query optimization
• Handling customer support responses
• Processing SEO optimization tasks
• Managing deployment pipelines

Sonnet - Complex Reasoning & Architecture

• Designing system architecture
• Making technology selection decisions
• Performing security audits
• Reviewing code for architectural patterns
• Creating complex AI/ML pipelines
• Providing language-specific expertise
• Orchestrating multi-agent workflows
• Handling business-critical legal/HR matters

Hybrid Orchestration Copy Section

Combine models for optimal performance and cost:

Planning Phase (Sonnet) → Execution Phase (Haiku) → Review Phase (Sonnet)

Example:
backend-architect (Sonnet) designs API
  ↓
Generate endpoints (Haiku) implements spec
  ↓
test-automator (Haiku) creates tests
  ↓
code-reviewer (Sonnet) validates architecture

Performance & Quality Copy Chapter

Optimized Token Usage Copy Section

• Isolated plugins load only what you need
• Granular architecture reduces unnecessary context
• Progressive disclosure (skills) loads knowledge on demand
• Clear boundaries prevent context pollution

Component Coverage Copy Section

• Full component coverage - every plugin includes at least one agent, command, or skill
• 100% component availability - all 202 local agents accessible across plugins
• Efficient distribution - 5.5 components per plugin average

Discoverability Copy Section

• Clear plugin names convey purpose immediately
• Logical categorization with 26 well-defined categories
• Searchable documentation with cross-references
• Easy to find the right tool for the job

Design Patterns Copy Chapter

Pattern 1: Single-Purpose Plugin Copy Section

Each plugin focuses on one domain:

python-development/
├── agents/           # Python language experts
├── commands/         # Python project scaffolding
└── skills/           # Python-specific knowledge

Benefits:

• Clear responsibility
• Easy to maintain
• Minimal token usage
• Composable with other plugins

Pattern 2: Workflow Orchestration Copy Section

Orchestrator plugins coordinate multiple agents:

full-stack-orchestration/
└── commands/
    └── full-stack-feature.md    # Coordinates 7+ agents

Orchestration:

1. backend-architect (design API)
2. database-architect (design schema)
3. frontend-developer (build UI)
4. test-automator (create tests)
5. security-auditor (security review)
6. deployment-engineer (CI/CD)
7. observability-engineer (monitoring)

Pattern 3: Agent + Skill Integration Copy Section

Agents provide reasoning, skills provide knowledge:

User: "Build FastAPI project with async patterns"
  ↓
fastapi-pro agent (orchestrates)
  ↓
fastapi-templates skill (provides patterns)
  ↓
python-scaffold command (generates project)

Pattern 4: Multi-Plugin Composition Copy Section

Complex workflows use multiple plugins:

Feature Development Workflow:
1. backend-development:feature-development
2. security-scanning:security-hardening
3. unit-testing:test-generate
4. comprehensive-review:full-review
5. cicd-automation:workflow-automate
6. observability-monitoring:monitor-setup

Versioning & Updates Copy Chapter

Marketplace Updates Copy Section

• Marketplace catalog in .claude-plugin/marketplace.json
• Semantic versioning for plugins
• Backward compatibility maintained
• Clear migration guides for breaking changes

Plugin Updates Copy Section

• Individual plugin updates don't affect others
• Skills can be updated independently
• Agents can be added/removed without breaking workflows
• Commands maintain stable interfaces

Contributing Guidelines Copy Chapter

Adding a Plugin Copy Section

1. Create plugin directory: plugins/{plugin-name}/
2. Add agents and/or commands
3. Optionally add skills
4. Update marketplace.json
5. Document in appropriate category

Adding an Agent Copy Section

1. Create plugins/{plugin-name}/agents/{agent-name}.md
2. Add frontmatter (name, description, model)
3. Write comprehensive system prompt
4. Update plugin definition

Adding a Skill Copy Section

1. Create plugins/{plugin-name}/skills/{skill-name}/SKILL.md
2. Add YAML frontmatter (name, description with "Use when")
3. Write skill content with progressive disclosure
4. Add to plugin's skills array in marketplace.json

Quality Standards Copy Section

• Clear naming - Hyphen-case, descriptive
• Focused scope - Single responsibility
• Complete documentation - What, when, how
• Tested functionality - Verify before committing
• Spec compliance - Follow Anthropic guidelines

See Also Copy Chapter

• Agent Skills - Modular knowledge packages
• Agent Reference - Complete agent catalog
• Plugin Reference - All 92 marketplace plugins
• Usage Guide - Commands and workflows

File: docs/plugins.md Copy Chapter

Complete Plugin Reference

Browse all 92 marketplace plugins organized by category: 91 local plugins plus 1 externally hosted git-subdir entry (pensyve).

Quick Start - Essential Plugins Copy Chapter

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

Development Essentials Copy Section

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.

Full-Stack Development Copy Section

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.

Testing & Quality Copy Section

unit-testing - Automated test generation

/plugin install unit-testing

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

Infrastructure & Operations Copy Section

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.

Language Support Copy Section

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.

Complete Plugin Catalog Copy Chapter

🎨 Development (6 plugins) Copy Section

📚 Documentation (5 plugins) Copy Section

🔄 Workflows (7 plugins) Copy Section

✅ Testing (1 plugin) Copy Section

🔍 Quality (4 plugins) Copy Section

🛠️ Utilities (5 plugins) Copy Section

🤖 AI & ML (6 plugins) Copy Section

🧠 Memory (1 external plugin) Copy Section

📊 Data (2 plugins) Copy Section

🗄️ Database (2 plugins) Copy Section

🚨 Operations (4 plugins) Copy Section

⚡ Performance (2 plugins) Copy Section

☁️ Infrastructure (5 plugins) Copy Section

🔒 Security (6 plugins) Copy Section

🛡️ Governance (3 plugins) Copy Section

🔄 Modernization (2 plugins) Copy Section

🌐 API (2 plugins) Copy Section

📢 Marketing (5 plugins) Copy Section

💼 Business (5 plugins) Copy Section

💻 Languages (10 plugins) Copy Section

🔗 Blockchain (1 plugin) Copy Section

💰 Finance (1 plugin) Copy Section

💳 Payments (1 plugin) Copy Section

🎮 Gaming (1 plugin) Copy Section

♿ Accessibility (1 plugin) Copy Section

🎨 Creative (3 plugins) Copy Section

Plugin Structure Copy Chapter

Each plugin contains:

• agents/ - Specialized agents for that domain
• commands/ - Tools and workflows specific to that plugin
• skills/ - Optional modular knowledge packages (progressive disclosure)

Example:

plugins/python-development/
├── agents/
│   ├── python-pro.md
│   ├── django-pro.md
│   └── fastapi-pro.md
├── commands/
│   └── python-scaffold.md
└── skills/
    ├── async-python-patterns/
    ├── python-testing-patterns/
    ├── python-packaging/
    ├── python-performance-optimization/
    └── uv-package-manager/

Installation Copy Chapter

Step 1: Add the Marketplace Copy Section

/plugin marketplace add wshobson/agents

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

Step 2: Install Specific Plugins Copy Section

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, commands, and skills into Claude's context.

Plugin Design Principles Copy Chapter

Single Responsibility Copy Section

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

Minimal Token Usage Copy Section

• Install only what you need
• Each plugin loads only its specific agents and tools
• No unnecessary resources loaded into context
• Better context efficiency with granular plugins

Composability Copy Section

• Mix and match plugins for complex workflows
• Workflow orchestrators compose focused plugins
• Clear boundaries between plugins
• No forced feature bundling

See Also Copy Chapter

• Agent Skills - 181 specialized skills across plugins
• Agent Reference - Complete agent catalog
• Usage Guide - Commands and workflows
• Architecture - Design principles

File: docs/usage.md Copy Chapter

Usage Guide

Complete guide to using agents, slash commands, and multi-agent workflows.

Overview Copy Chapter

The plugin ecosystem provides two primary interfaces:

1. Slash Commands - Direct invocation of tools and workflows
2. Natural Language - Claude reasons about which agents to use

How Installation Actually Works Copy Chapter

The plugin is the unit of installation; skills and agents come along with it.

1. /plugin marketplace add wshobson/agents registers the catalog. It loads
   nothing into context.
2. /plugin install installs one plugin — its agents, commands, and
   skills together. Install the 2–3 plugins that cover your domain, not
   individual skills.
3. Auto-discovery operates inside what you installed. Claude Code discovers
   an installed plugin's skills automatically and activates them when your task
   matches a skill's description. You never select skills by hand.
4. AGENTS.md and the docs/ catalogs are for browsing what exists; reading
   them installs nothing.

Slash Commands Copy Chapter

Slash commands are the primary interface for working with agents and workflows. Each plugin provides namespaced commands that you can run directly.

Command Format Copy Section

/plugin-name:command-name [arguments]

Discovering Commands Copy Section

List all available slash commands from installed plugins:

/plugin

Benefits of Slash Commands Copy Section

• 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

Natural Language Copy Chapter

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.

Command Reference by Category Copy Chapter

Development & Features Copy Section

Testing & Quality Copy Section

Code Quality & Review Copy Section

Debugging & Troubleshooting Copy Section

Security Copy Section

Infrastructure & Deployment Copy Section

Data & ML Copy Section

Documentation Copy Section

Refactoring & Maintenance Copy Section

Database Copy Section

Git & PR Workflows Copy Section

Project Scaffolding Copy Section

AI & LLM Development Copy Section

Testing & Performance Copy Section

Team Collaboration Copy Section

Accessibility Copy Section

API Development Copy Section

Context Management Copy Section

Multi-Agent Workflow Examples Copy Chapter

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

Full-Stack Development Copy Section

# 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

Security Hardening Copy Section

# 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

Data/ML Pipeline Copy Section

# 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

Incident Response Copy Section

# 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

C4 Architecture Documentation Copy Section

# Generate comprehensive C4 architecture documentation
/c4-architecture:c4-architecture

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

Orchestration: c4-code → c4-component → c4-container → c4-context

What happens:

1. Code Level: Bottom-up analysis of all subdirectories, creating code-level documentation with function signatures and dependencies
2. Component Level: Synthesizes code documentation into logical components with interfaces and relationships
3. Container Level: Maps components to deployment containers with OpenAPI/Swagger API specifications
4. Context Level: Creates high-level system context with personas, user journeys, and external dependencies

Output: Complete C4 documentation in C4-Documentation/ directory with Mermaid diagrams at all levels (Context, Container, Component, Code)

Command Arguments and Options Copy Chapter

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

# C4 architecture documentation generation
/c4-architecture:c4-architecture

Combining Natural Language and Commands Copy Chapter

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"

Best Practices Copy Chapter

When to Use Slash Commands Copy Section

• Structured workflows - Multi-step processes with clear phases
• Repetitive tasks - Operations you perform frequently
• Precise control - When you need specific parameters
• Discovery - Exploring available functionality

When to Use Natural Language Copy Section

• Exploratory work - When you're not sure which tool to use
• Complex reasoning - When Claude needs to coordinate multiple agents
• Contextual decisions - When the right approach depends on the situation
• Ad-hoc tasks - One-off operations that don't fit a command

Workflow Composition Copy Section

Compose multiple plugins for complex scenarios:

# 1. Start with feature development
/backend-development:feature-development payment processing API

# 2. Add security hardening
/security-scanning:security-hardening

# 3. Generate comprehensive tests
/unit-testing:test-generate

# 4. Review the implementation
/comprehensive-review:full-review

# 5. Set up CI/CD
/cicd-automation:workflow-automate

# 6. Add monitoring
/observability-monitoring:monitor-setup

Agent Skills Integration Copy Chapter

Agent Skills work alongside commands to provide deep expertise:

User: "Set up FastAPI project with async patterns"
→ Activates: fastapi-templates skill
→ Invokes: /python-development:python-scaffold
→ Result: Production-ready FastAPI project with best practices

User: "Implement Kubernetes deployment with Helm"
→ Activates: helm-chart-scaffolding, k8s-manifest-generator skills
→ Guides: kubernetes-architect agent
→ Result: Production-grade K8s manifests with Helm charts

See Agent Skills for details on the 181 specialized skills.

See Also Copy Chapter

• Agent Skills - Specialized knowledge packages
• Agent Reference - Complete agent catalog
• Plugin Reference - All 92 marketplace plugins
• Architecture - Design principles

File: plugins/ui-design/README.md Copy Chapter

UI/UX Design Plugin for Claude Code

Comprehensive UI/UX design plugin covering mobile (iOS, Android, React Native) and web applications with modern design patterns, accessibility, and design systems.

Features Copy Chapter

Core Capabilities Copy Section

• Design Systems: Token architecture, theming, multi-brand systems
• Accessibility: WCAG 2.2 compliance, inclusive design patterns
• Responsive Design: Container queries, fluid layouts, breakpoints
• Mobile Design: iOS HIG, Material Design 3, React Native patterns
• Web Components: React/Vue/Svelte patterns, CSS-in-JS
• Interaction Design: Microinteractions, motion, transitions

Skills Copy Chapter

Agents Copy Chapter

Commands Copy Chapter

Installation Copy Chapter

/plugin install ui-design

Usage Examples Copy Chapter

Design Review Copy Section

/ui-design:design-review --file src/components/Button.tsx

Create Component Copy Section

/ui-design:create-component Card --platform react

Accessibility Audit Copy Section

/ui-design:accessibility-audit --level AA

Design System Setup Copy Section

/ui-design:design-system-setup --name "Acme Design System"

Key Technologies Covered Copy Chapter

Web Copy Section

• CSS Grid, Flexbox, Container Queries
• Tailwind CSS, CSS-in-JS (Styled Components, Emotion)
• React, Vue, Svelte component patterns
• Framer Motion, GSAP animations

Mobile Copy Section

• iOS: SwiftUI, UIKit, Human Interface Guidelines
• Android: Jetpack Compose, Material Design 3
• React Native: StyleSheet, Reanimated, React Navigation

Design Systems Copy Section

• Design tokens (Style Dictionary, Figma Variables)
• Component libraries (Storybook documentation)
• Multi-brand theming

Accessibility Copy Section

• WCAG 2.2 AA/AAA compliance
• ARIA patterns and semantic HTML
• Screen reader compatibility
• Keyboard navigation

Generated Artifacts Copy Chapter

The plugin creates artifacts in .ui-design/:

.ui-design/
├── design-system.config.json    # Design system configuration
├── component_specs/             # Generated component specifications
├── audit_reports/               # Accessibility audit reports
└── tokens/                      # Generated design tokens

Requirements Copy Chapter

• Claude Code CLI
• Node.js 18+ (for design token generation)

License Copy Chapter

MIT License

File: plugins/startup-business-analyst/README.md Copy Chapter

Startup Business Analyst Plugin

Comprehensive business analysis plugin specialized for early-stage startups, providing market sizing, financial modeling, team planning, and strategic research capabilities.

Overview Copy Chapter

This plugin equips Claude with expert-level startup business analysis capabilities, focusing on the critical calculations and strategic insights needed by entrepreneurs, founders, and investors.

Features Copy Chapter

5 Specialized Skills Copy Section

• market-sizing-analysis - TAM/SAM/SOM calculations with multiple methodologies
• startup-financial-modeling - 3-5 year financial projections with scenarios
• team-composition-analysis - Organizational design and compensation planning
• competitive-landscape - Market positioning and competitive strategy
• startup-metrics-framework - Key metrics for different business models

3 Interactive Commands Copy Section

• /startup-business-analyst:market-opportunity - Generate market opportunity analysis
• /startup-business-analyst:financial-projections - Create financial models with scenarios
• /startup-business-analyst:business-case - Generate comprehensive business case documents

1 Expert Agent Copy Section

• startup-analyst - Specialized agent for early-stage startup analysis

Installation Copy Chapter

/plugin install startup-business-analyst@claude-code-workflows

Usage Copy Chapter

Automatic Skill Activation Copy Section

Skills activate automatically based on your questions:

"What's the TAM for a B2B SaaS project management tool?"
→ Activates market-sizing-analysis skill

"Create a 3-year financial model for my marketplace startup"
→ Activates startup-financial-modeling skill

"What are the key SaaS metrics I should track?"
→ Activates startup-metrics-framework skill

Commands Copy Section

Market Opportunity Analysis:

/startup-business-analyst:market-opportunity

Generates comprehensive market sizing with TAM/SAM/SOM breakdown.

Financial Projections:

/startup-business-analyst:financial-projections

Creates 3-scenario financial model with revenue, costs, and runway.

Business Case:

/startup-business-analyst:business-case

Produces investor-ready business case document.

Agent Usage Copy Section

The startup-analyst agent triggers automatically for business-related questions:

"Help me analyze the competitive landscape for my fintech startup"
"What should my team structure look like at $1M ARR?"
"Calculate my customer acquisition payback period"

Skills Reference Copy Chapter

Market Sizing Analysis Copy Section

Covers three methodologies:

• Top-down: Industry reports and market research
• Bottom-up: Customer segment calculations
• Value theory: Problem value and willingness to pay

Includes templates for SaaS, marketplace, consumer, B2B, and fintech.

Startup Financial Modeling Copy Section

Components:

• Revenue projections (by customer segment)
• Cost structure (COGS, S&M, R&D, G&A)
• Cash flow and runway calculations
• Headcount planning
• Scenario analysis (conservative, base, optimistic)

Team Composition Analysis Copy Section

Covers:

• Role-by-stage recommendations
• Compensation benchmarks (US-focused)
• Equity/options allocation strategies
• Full-time vs. contractor decisions
• Organizational design

Competitive Landscape Copy Section

Frameworks:

• Porter's Five Forces
• Blue Ocean Strategy
• Positioning maps
• Go-to-market strategy
• Competitive pricing analysis

Startup Metrics Framework Copy Section

Business model coverage:

• SaaS: ARR, MRR, NRR, CAC, LTV, Magic Number
• Marketplace: GMV, Take Rate, Liquidity
• Consumer: DAU/MAU, Retention, Virality
• B2B: ACR, Win Rate, Sales Cycle
• Fintech: TPV, Monetization Rate, Fraud Rate

Examples Copy Chapter

Example 1: TAM/SAM/SOM Calculation Copy Section

"Calculate TAM/SAM/SOM for an AI-powered email marketing tool for e-commerce"

→ Skill activates and provides:

- TAM: Total email marketing software market
- SAM: AI-powered tools for e-commerce segment
- SOM: Realistic 3-5 year capture
- Methodology explanation
- Market growth assumptions
- Data sources and citations

Example 2: Financial Model Copy Section

"Create a 3-year financial model for a SaaS product with $50/mo pricing"

→ Command generates:

- Revenue by cohort
- Cost structure breakdown
- Headcount plan
- Cash flow projection
- Runway calculation
- 3 scenarios (conservative/base/optimistic)

Example 3: Competitive Analysis Copy Section

"Analyze competitors in the project management software space"

→ Agent provides:

- Competitive landscape map
- Feature comparison matrix
- Pricing analysis
- Market positioning recommendations
- Differentiation opportunities

Best Practices Copy Chapter

1. Provide Context: Share your business model, target market, and stage
2. Be Specific: Include numbers, timeframes, and assumptions where possible
3. Iterate: Start with high-level analysis, then drill into details
4. Validate Assumptions: Question and refine assumptions with the agent
5. Cite Sources: Ask for data sources and validation methods

Requirements Copy Chapter

• Claude Code CLI
• Internet access (for web research capabilities)
• No external dependencies

Model Configuration Copy Chapter

• Agent Model: inherit (uses your session default model)
• Recommended: Sonnet for balance of speed and quality
• Use Opus for: Complex multi-market analysis or detailed financial models

Contributing Copy Chapter

Found an issue or have suggestions? Please open an issue or PR at:
https://github.com/wshobson/agents

License Copy Chapter

MIT License - see repository LICENSE file for details.

Version History Copy Chapter

• 1.0.0 (2026-01-13): Initial release
  • 5 specialized skills
  • 3 interactive commands
  • 1 expert agent
  • Comprehensive startup analysis capabilities

File: plugins/llm-application-dev/README.md Copy Chapter

LLM Application Development Plugin for Claude Code

Build production-ready LLM applications, advanced RAG systems, and intelligent agents with modern AI patterns.

Version 2.0.0 Highlights Copy Chapter

• LangGraph Integration: Updated from deprecated LangChain patterns to LangGraph StateGraph workflows
• Modern Model Support: Claude Opus 4.8/Sonnet 5/Haiku 4.5 and GPT-5.4/GPT-5-mini
• Voyage AI Embeddings: Recommended embedding models for Claude applications
• Structured Outputs: Pydantic-based structured output patterns

Features Copy Chapter

Core Capabilities Copy Section

• RAG Systems: Production retrieval-augmented generation with hybrid search
• Vector Search: Pinecone, Qdrant, Weaviate, Milvus, pgvector optimization
• Agent Architectures: LangGraph-based agents with memory and tool use
• Prompt Engineering: Advanced prompting techniques with model-specific optimization

Key Technologies Copy Section

• LangChain 1.x / LangGraph for agent workflows
• Voyage AI, OpenAI, and open-source embedding models
• HNSW, IVF, and Product Quantization index strategies
• Async patterns with checkpointers for durable execution

Agents Copy Chapter

Skills Copy Chapter

Commands Copy Chapter

Installation Copy Chapter

/plugin install llm-application-dev

Requirements Copy Chapter

• LangChain >= 1.2.0
• LangGraph >= 0.3.0
• Python 3.11+

Changelog Copy Chapter

2.0.0 (January 2026) Copy Section

• Breaking: Migrated from LangChain 0.x to LangChain 1.x/LangGraph
• Breaking: Updated model references to Claude 4.6 and GPT-5.4
• Added Voyage AI as primary embedding recommendation for Claude apps
• Added LangGraph StateGraph patterns replacing deprecated initialize_agent()
• Added structured outputs with Pydantic
• Added async patterns with checkpointers
• Fixed security issue: replaced unsafe code execution with AST-based safe math evaluation
• Updated hybrid search with modern Pinecone client API

1.2.2 Copy Section

• Minor bug fixes and documentation updates

License Copy Chapter

MIT License - See the plugin configuration for details.

File: plugins/dotnet-contribution/README.md Copy Chapter

.NET Backend Development Plugin

A comprehensive plugin for .NET backend development with C#, ASP.NET Core, Entity Framework Core, and Dapper.

Overview Copy Chapter

This plugin provides agents, skills, and patterns for building production-grade .NET applications. It focuses on modern C# (12/13), ASP.NET Core 8+, and enterprise development patterns.

Contents Copy Chapter

Agents Copy Section

Skills Copy Section

Assets Copy Section

• service-template.cs - Complete service implementation with Result pattern, validation, caching
• repository-template.cs - Repository implementations with Dapper and EF Core

References Copy Section

• ef-core-best-practices.md - EF Core optimization guide
• dapper-patterns.md - Advanced Dapper usage patterns

Usage Copy Chapter

With Claude Code CLI Copy Section

# General .NET architecture help
claude -p "Act as dotnet-architect and design a caching strategy for my product catalog"

# Code review
claude -p "Act as dotnet-architect and review this async code for issues"

# Implementation help
claude -p "Use dotnet-backend-patterns skill to implement a repository with Dapper"

Example Prompts Copy Section

1. API Design

   text Copy

   Act as dotnet-architect. Design a REST API for order management with proper
   DTOs, validation, and error handling.

2. Performance Review

   text Copy

   Act as dotnet-architect. Review this EF Core query for N+1 problems and
   suggest optimizations.

3. Architecture Decision

   text Copy

   Act as dotnet-architect. Should I use EF Core or Dapper for this high-throughput
   read scenario? Explain trade-offs.

Topics Covered Copy Chapter

C# Language Copy Section

• Async/await patterns and pitfalls
• LINQ optimization
• Records and immutability
• Pattern matching
• Nullable reference types
• Memory-efficient programming

ASP.NET Core Copy Section

• Minimal APIs and Controllers
• Dependency Injection (Scoped, Singleton, Transient, Keyed)
• Configuration with IOptions
• Middleware pipeline
• Authentication/Authorization
• Health checks

Data Access Copy Section

• Entity Framework Core best practices
• Dapper for high-performance queries
• Repository pattern
• Unit of Work
• Connection management
• Transaction handling

Caching Copy Section

• IMemoryCache
• IDistributedCache with Redis
• Multi-level caching
• Cache invalidation
• Distributed locking

Testing Copy Section

• xUnit fundamentals
• Moq for mocking
• Integration tests with WebApplicationFactory
• Test patterns and best practices

Stack Compatibility Copy Chapter

Contributing Copy Chapter

Contributions welcome! Please ensure:

• Code examples compile and follow C# conventions
• Patterns are production-tested
• Documentation is clear and includes examples

License Copy Chapter

MIT License - See repository root for details.

2. Official Technical Reference & Guides (wshobson/wshobson.github.io) Copy Chapter

Seth Hobson

Seth Hobson is a software engineer with 15+ years of experience in applied AI, data engineering, and distributed systems. He is the founder of Major 7 Apps, creator of the wshobson/agents plugin marketplace, and author of the AI Primitives newsletter.

Currently Senior AI Engineer at United Data Technologies; previously senior software engineer at Apple (2015–2021) and Kuali (2021–2023).

Links Copy Chapter

• sethhobson.com: personal site (this site)
• GitHub: open-source work
• Major 7 Apps: product studio — hub linking to all current applications
• AI Primitives: weekly newsletter on applied AI, agentic systems, and engineering primitives
• LinkedIn: professional profile

Projects Copy Chapter

• agents: agentic plugin marketplace — 82 plugins, 191 agents, 155 skills, 102 commands, shipped to five harnesses (Claude Code, Codex CLI, Cursor, OpenCode, Gemini CLI)
• commands: 52 multi-agent orchestration slash commands for Claude Code
• Capital Companion: AI-powered trading insights, stock analysis, and risk management
• Pensyve: universal memory runtime for AI agents — episodic/semantic/procedural memory, 8-signal fusion retrieval, FSRS forgetting
• Maverick MCP: personal stock-analysis MCP server
• Tiingo MCP: production-grade MCP server for the Tiingo financial data API, 17 tools, on PyPI