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
License:MIT
Update:6 months ago
Show doc for...
Tokens:
Raw
### Configure Development Environment with .env.example and Makefile

Source: https://github.com/wshobson/agents/blob/main/plugins/python-development/commands/python-scaffold.md

Provides an example `.env.example` file for environment variables and a `Makefile` for common development tasks such as installation, running the development server, testing, linting, formatting, and cleaning build artifacts.

```env
# Application
PROJECT_NAME="Project Name"
VERSION="0.1.0"
DEBUG=True

# API
API_V1_PREFIX="/api/v1"
ALLOWED_ORIGINS=["http://localhost:3000"]

# Database
DATABASE_URL="postgresql://user:pass@localhost:5432/dbname"

# Security
SECRET_KEY="your-secret-key-here"
```

```makefile
.PHONY: install dev test lint format clean

install:
	uv sync

dev:
	uv run uvicorn src.project_name.main:app --reload

test:
	uv run pytest -v

lint:
	uv run ruff check .

format:
	uv run ruff format .

clean:
	find . -type d -name __pycache__ -exec rm -rf {} +
	find . -type f -name "*.pyc" -delete
	rm -rf .pytest_cache .ruff_cache
```

--------------------------------

### CLI Usage Examples

Source: https://github.com/wshobson/agents/blob/main/plugins/python-development/skills/python-packaging/SKILL.md

Demonstrates how to install and use a CLI tool registered via `pyproject.toml`. Shows examples for the `greet` and `repeat` commands.

```bash
pip install -e .
my-tool greet World
my-tool greet Alice --greeting="Hi"
my-tool repeat --count=3

```

--------------------------------

### Development Environment Setup Script

Source: https://github.com/wshobson/agents/blob/main/plugins/cicd-automation/commands/workflow-automate.md

This bash script (scripts/setup-dev-environment.sh) automates the setup of the development environment. It checks for necessary command-line tools (git, node, npm, docker, docker-compose), installs project dependencies using npm, sets up global npm packages, installs and configures pre-commit hooks, starts local services defined in docker-compose.dev.yml, waits for services to be ready, initializes the database, and sets up environment variables by copying from a template.

```bash
#!/bin/bash
# scripts/setup-dev-environment.sh

set -euo pipefail

echo "🚀 Setting up development environment..."

# Check prerequisites
check_prerequisites() {
    echo "Checking prerequisites..."

    commands=("git" "node" "npm" "docker" "docker-compose")
    for cmd in "${commands[@]}"; do
        if ! command -v "$cmd" &> /dev/null; then
            echo "❌ $cmd is not installed"
            exit 1
        fi
    done

    echo "✅ All prerequisites installed"
}

# Install dependencies
install_dependencies() {
    echo "Installing dependencies..."
    npm ci

    # Install global tools
    npm install -g @commitlint/cli @commitlint/config-conventional
    npm install -g semantic-release

    # Install pre-commit
    pip install pre-commit
    pre-commit install
    pre-commit install --hook-type commit-msg
}

# Setup local services
setup_services() {
    echo "Setting up local services..."

    # Create docker network
    docker network create dev-network 2>/dev/null || true

    # Start services
    docker-compose -f docker-compose.dev.yml up -d

    # Wait for services
    echo "Waiting for services to be ready..."
    ./scripts/wait-for-services.sh
}

# Initialize database
initialize_database() {
    echo "Initializing database..."
    npm run db:migrate
    npm run db:seed
}

# Setup environment variables
setup_environment() {
    echo "Setting up environment variables..."

    if [ ! -f .env.local ]; then
        cp .env.example .env.local
        echo "✅ Created .env.local from .env.example"
        echo "⚠️  Please update .env.local with your values"
    fi
}

# Main execution
main() {
    check_prerequisites
    install_dependencies
    setup_services
    setup_environment
    initialize_database

    echo "✅ Development environment setup complete!"
    echo ""
    echo "Next steps:"
    echo "1. Update .env.local with your configuration"
    echo "2. Run 'npm run dev' to start the development server"
    echo "3. Visit http://localhost:3000"
}

main

```

--------------------------------

### Conductor Interactive Setup

Source: https://github.com/wshobson/agents/blob/main/README.md

Initiates the interactive setup for the Conductor plugin, guiding the user through defining product vision, tech stack, workflow rules, and style guides.

```bash
/conductor:setup
```

--------------------------------

### Python Virtual Environment Setup

Source: https://github.com/wshobson/agents/blob/main/plugins/conductor/templates/code_styleguides/python.md

Provides bash commands for setting up and managing Python virtual environments, including creation, activation on different operating systems, and installing dependencies.

```bash
```bash
# Create virtual environment
python -m venv .venv

# Activate (Unix/macOS)
source .venv/bin/activate

# Activate (Windows)
.venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt
```
```

--------------------------------

### Install Startup Business Analyst Plugin

Source: https://github.com/wshobson/agents/blob/main/plugins/startup-business-analyst/README.md

Command to install the startup-business-analyst plugin for Claude code workflows. This is a one-time setup command.

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

--------------------------------

### Install cloud-infrastructure Plugin

Source: https://github.com/wshobson/agents/blob/main/docs/plugins.md

Install the cloud-infrastructure plugin for AWS/Azure/GCP architecture, Kubernetes setup, and Terraform IaC.

```bash
/plugin install cloud-infrastructure
```

--------------------------------

### Install ArgoCD (Helm)

Source: https://github.com/wshobson/agents/blob/main/plugins/kubernetes-operations/skills/gitops-workflow/references/argocd-setup.md

Installs ArgoCD using Helm, a package manager for Kubernetes. This simplifies the installation and management process.

```bash
helm repo add argo https://argoproj.github.io/argo-helm
helm install argocd argo/argo-cd -n argocd --create-namespace
```

--------------------------------

### Plugin Installation Syntax

Source: https://github.com/wshobson/agents/blob/main/README.md

Demonstrates the correct way to install a plugin by name rather than by individual agent.

```bash
# ❌ Wrong - can't install agents directly
/plugin install typescript-pro

# ✅ Right - install the plugin
/plugin install javascript-typescript@claude-code-workflows
```

--------------------------------

### Install ArgoCD (Standard)

Source: https://github.com/wshobson/agents/blob/main/plugins/kubernetes-operations/skills/gitops-workflow/references/argocd-setup.md

Installs ArgoCD using standard Kubernetes manifests. This method requires kubectl and applies the official ArgoCD installation YAML.

```bash
kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
```

--------------------------------

### Initialize New Projects

Source: https://github.com/wshobson/agents/blob/main/plugins/python-development/skills/uv-package-manager/references/advanced-patterns.md

Standard workflow for setting up a new project with UV, including dependency management and environment configuration.

```bash
# Complete workflow
uv init my-project
cd my-project

# Set Python version
uv python pin 3.12

# Add dependencies
uv add fastapi uvicorn pydantic

# Add dev dependencies
uv add --dev pytest black ruff mypy

# Create structure
mkdir -p src/my_project tests

# Run tests
uv run pytest

# Format code
uv run black .
uv run ruff check .
```

--------------------------------

### Install ArgoCD (High Availability)

Source: https://github.com/wshobson/agents/blob/main/plugins/kubernetes-operations/skills/gitops-workflow/references/argocd-setup.md

Installs a high-availability version of ArgoCD using Kubernetes manifests. This is suitable for production environments requiring resilience.

```bash
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/ha/install.yaml
```

--------------------------------

### Helm Pre-Install Hook Example (templates/pre-install-job.yaml)

Source: https://github.com/wshobson/agents/blob/main/plugins/kubernetes-operations/skills/helm-chart-scaffolding/SKILL.md

Defines a Helm pre-install hook as a Kubernetes Job. This hook runs before the main chart resources are installed, typically used for tasks like database schema migrations or setup. It's configured with a specific weight and delete policy.

```yaml
# templates/pre-install-job.yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: {{ include "my-app.fullname" . }}-db-setup
  annotations:
    "helm.sh/hook": pre-install
    "helm.sh/hook-weight": "-5"
    "helm.sh/hook-delete-policy": hook-succeeded
spec:
  template:
    spec:
      containers:
      - name: db-setup
        image: postgres:15
        command: ["psql", "-c", "CREATE DATABASE myapp"]
      restartPolicy: Never
```

--------------------------------

### Market Sizing Analysis Example (Markdown)

Source: https://github.com/wshobson/agents/blob/main/plugins/startup-business-analyst/README.md

Example of a user query to calculate TAM/SAM/SOM for a specific product, demonstrating the expected output format including methodology, assumptions, and data sources.

```markdown
"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
```

--------------------------------

### Install Helm Chart with Environment-Specific Values (Bash)

Source: https://github.com/wshobson/agents/blob/main/plugins/kubernetes-operations/skills/helm-chart-scaffolding/SKILL.md

Command to install a Helm chart using environment-specific values and deploying to a designated namespace. This example installs `my-app` using `values-prod.yaml` into the `production` namespace.

```bash
helm install my-app ./my-app -f values-prod.yaml --namespace production
```

--------------------------------

### Install code-documentation Plugin

Source: https://github.com/wshobson/agents/blob/main/docs/plugins.md

Use this command to install the code-documentation plugin for automated doc generation, code explanation, and tutorial creation.

```bash
/plugin install code-documentation
```

--------------------------------

### Markdown README Structure for Project Documentation

Source: https://github.com/wshobson/agents/blob/main/plugins/python-development/skills/python-code-style/SKILL.md

Provides a standard Markdown structure for a project's README file. This includes sections for the project name, a brief description, installation instructions, a quick start guide, configuration details, and development setup. A well-structured README is crucial for onboarding new users and contributors.

```markdown
# Project Name

Brief description of what the project does.

## Installation

```bash
pip install myproject
```

## Quick Start

```python
from myproject import Client

client = Client(api_key="...")
result = client.process(data)
```

## Configuration

Document environment variables and configuration options.

## Development

```bash
pip install -e ".[dev]"
pytest
```

```

--------------------------------

### Best Practices for Project Setup

Source: https://github.com/wshobson/agents/blob/main/plugins/python-development/skills/uv-package-manager/references/advanced-patterns.md

Recommended practices for setting up Python projects with uv, focusing on reproducibility, dependency management, and efficient workflows.

```APIDOC
## Best Practices

### Project Setup

1.  **Always use lockfiles** for reproducible builds.
2.  **Pin Python version** using a `.python-version` file.
3.  **Separate development dependencies** from production dependencies.
4.  **Use `uv run`** instead of manually activating virtual environments.
5.  **Commit `uv.lock`** to version control.
6.  **Use `--frozen` in CI** for consistent and faster builds.
7.  **Leverage the global cache** for improved performance.
8.  **Use workspaces** for managing monorepos.
9.  **Export `requirements.txt`** for compatibility with other tools.
10. **Keep `uv` updated** to benefit from the latest features and improvements.
```

--------------------------------

### Configure ArgoCD Ingress

Source: https://github.com/wshobson/agents/blob/main/plugins/kubernetes-operations/skills/gitops-workflow/references/argocd-setup.md

Defines an Ingress resource to expose the ArgoCD server. This example uses nginx-ingress and cert-manager for TLS termination.

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: argocd-server-ingress
  namespace: argocd
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
    nginx.ingress.kubernetes.io/ssl-passthrough: "true"
    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
spec:
  ingressClassName: nginx
  rules:
    - host: argocd.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: argocd-server
                port:
                  number: 443
  tls:
    - hosts:
        - argocd.example.com
      secretName: argocd-secret
```

--------------------------------

### Troubleshoot Helm Installation Failures (Bash)

Source: https://github.com/wshobson/agents/blob/main/plugins/kubernetes-operations/skills/helm-chart-scaffolding/SKILL.md

This command performs a dry run of a Helm installation, simulating the process without actually deploying resources. Combined with `--debug`, it provides detailed output to help diagnose installation problems. `kubectl get events` is then used to inspect Kubernetes events for further clues.

```bash
helm install my-app ./my-app --dry-run --debug
kubectl get events --sort-by='.lastTimestamp'
```

--------------------------------

### Combine Commands and Natural Language for Workflows

Source: https://github.com/wshobson/agents/blob/main/docs/usage.md

This example demonstrates how to start a structured workflow with a command and then provide further natural language guidance for refinement and specific requirements.

```bash
# 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"
```

--------------------------------

### Access ArgoCD UI and Get Password

Source: https://github.com/wshobson/agents/blob/main/plugins/kubernetes-operations/skills/gitops-workflow/references/argocd-setup.md

Provides commands to access the ArgoCD UI via port forwarding and retrieve the initial administrator password. Requires kubectl.

```bash
# Port forward
kubectl port-forward svc/argocd-server -n argocd 8080:443

# Get initial admin password
argocd admin initial-password -n argocd
```

--------------------------------

### Fastify Basic Server Setup

Source: https://github.com/wshobson/agents/blob/main/plugins/javascript-typescript/skills/nodejs-backend-patterns/SKILL.md

Initializes a high-performance Fastify server with plugin registration and JSON schema validation for routes. Requires the fastify, @fastify/helmet, @fastify/cors, and @fastify/compress packages.

```typescript
import Fastify from "fastify";
import helmet from "@fastify/helmet";
import cors from "@fastify/cors";
import compress from "@fastify/compress";

const fastify = Fastify({
  logger: {
    level: process.env.LOG_LEVEL || "info",
    transport: {
      target: "pino-pretty",
      options: { colorize: true },
    },
  },
});

// Plugins
await fastify.register(helmet);
await fastify.register(cors, { origin: true });
await fastify.register(compress);

// Type-safe routes with schema validation
fastify.post<{
  Body: { name: string; email: string };
  Reply: { id: string; name: string };
}>(
  "/users",
  {
    schema: {
      body: {
        type: "object",
        required: ["name", "email"],
        properties: {
          name: { type: "string", minLength: 1 },
          email: { type: "string", format: "email" },
        },
      },
    },
  },
  async (request, reply) => {
    const { name, email } = request.body;
    return { id: "123", name };
  },
);

await fastify.listen({ port: 3000, host: "0.0.0.0" });
```

--------------------------------

### Agent Skills Integration Example 1

Source: https://github.com/wshobson/agents/blob/main/docs/usage.md

Demonstrates how user input can activate specific agent skills and invoke corresponding commands, resulting in a structured output. This example shows setting up a FastAPI project.

```text
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
```

--------------------------------

### Configure C Extensions

Source: https://github.com/wshobson/agents/blob/main/plugins/python-development/skills/python-packaging/references/advanced-patterns.md

Build C extensions using setuptools or setup.py with Cython support.

```toml
[build-system]
requires = ["setuptools>=61.0", "wheel", "Cython>=0.29"]
build-backend = "setuptools.build_meta"

[tool.setuptools]
ext-modules = [
    {name = "my_package.fast_module", sources = ["src/fast_module.c"]},
]
```

```python
# setup.py
from setuptools import setup, Extension

setup(
    ext_modules=[
        Extension(
            "my_package.fast_module",
            sources=["src/fast_module.c"],
            include_dirs=["src/include"],
        )
    ]
)
```

--------------------------------

### Select examples by semantic similarity in Python

Source: https://github.com/wshobson/agents/blob/main/plugins/llm-application-dev/skills/prompt-engineering-patterns/references/few-shot-learning.md

Uses sentence-transformers to calculate embedding-based similarity between a query and a set of examples. Returns the top k most relevant examples to guide the model.

```python
from sentence_transformers import SentenceTransformer
import numpy as np

class SemanticExampleSelector:
    def __init__(self, examples, model_name='all-MiniLM-L6-v2'):
        self.model = SentenceTransformer(model_name)
        self.examples = examples
        self.example_embeddings = self.model.encode([ex['input'] for ex in examples])

    def select(self, query, k=3):
        query_embedding = self.model.encode([query])
        similarities = np.dot(self.example_embeddings, query_embedding.T).flatten()
        top_indices = np.argsort(similarities)[-k:][::-1]
        return [self.examples[i] for i in top_indices]
```

--------------------------------

### Install documentation-generation Plugin

Source: https://github.com/wshobson/agents/blob/main/docs/plugins.md

Install the documentation-generation plugin for generating OpenAPI specs, Mermaid diagrams, and tutorials.

```bash
/plugin install documentation-generation
```

--------------------------------

### Execute Automated SAST Scripts and Compliance Scans

Source: https://github.com/wshobson/agents/blob/main/plugins/security-scanning/skills/sast-configuration/SKILL.md

Examples of running automated security scripts and executing compliance-specific scans. These are useful for project setup and meeting regulatory requirements like PCI-DSS.

```bash
./scripts/run-sast.sh --setup --language python --tools semgrep,sonarqube

semgrep --config p/pci-dss --json -o pci-scan-results.json
```

--------------------------------

### Initialize and Run plugin-eval

Source: https://github.com/wshobson/agents/blob/main/plugins/plugin-eval/README.md

Commands to set up the environment and execute evaluation or certification tasks for a specific skill.

```bash
cd plugins/plugin-eval
uv sync

# Evaluate a skill (static only, instant)
uv run plugin-eval score path/to/skill --depth quick

# Evaluate with LLM judge (~30s)
uv run plugin-eval score path/to/skill --depth standard

# Full certification (all layers, ~5 min)
uv run plugin-eval certify path/to/skill
```

--------------------------------

### Volatility 3 Framework Setup and Usage

Source: https://github.com/wshobson/agents/blob/main/plugins/reverse-engineering/skills/memory-forensics/SKILL.md

Instructions for installing the Volatility 3 framework and executing basic analysis commands. It requires a memory dump file and appropriate symbol tables to interpret OS-specific structures.

```bash
# Install Volatility 3
pip install volatility3

# Basic usage
vol -f memory.raw <plugin>

# With symbol path
vol -f memory.raw -s /path/to/symbols windows.pslist
```

--------------------------------

### Financial Model Example (Markdown)

Source: https://github.com/wshobson/agents/blob/main/plugins/startup-business-analyst/README.md

Example of a user query to generate a financial model for a SaaS product, detailing the expected components of the output, including revenue, costs, headcount, cash flow, and scenarios.

```markdown
"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)
```

--------------------------------

### Browse Available Plugins

Source: https://github.com/wshobson/agents/blob/main/docs/plugins.md

Use this command to see a list of all available plugins.

```bash
/plugin
```

--------------------------------

### Automate Accessibility Testing with GitHub Actions

Source: https://github.com/wshobson/agents/blob/main/plugins/accessibility-compliance/commands/accessibility-audit.md

A YAML configuration for a GitHub Actions workflow that installs dependencies, starts a local server, and executes accessibility tests using axe and pa11y. It includes artifact uploading to persist test reports.

```yaml
name: Accessibility Tests

on: [push, pull_request]

jobs:
  a11y-tests:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: "18"

      - name: Install and build
        run: |
          npm ci
          npm run build

      - name: Start server
        run: |
          npm start &
          npx wait-on http://localhost:3000

      - name: Run axe tests
        run: npm run test:a11y

      - name: Run pa11y
        run: npx pa11y http://localhost:3000 --standard WCAG2AA --threshold 0

      - name: Upload report
        uses: actions/upload-artifact@v3
        if: always()
        with:
          name: a11y-report
          path: a11y-report.html
```

--------------------------------

### Initialize and Configure Django Project

Source: https://github.com/wshobson/agents/blob/main/plugins/python-development/commands/python-scaffold.md

Commands and configuration to set up a Django project using uv, including the necessary dependencies for production and development.

```bash
uv add django django-environ django-debug-toolbar
django-admin startproject config .
python manage.py startapp core
```

```toml
[project]
name = "django-project"
version = "0.1.0"
requires-python = ">=3.11"
dependencies = [
    "django>=5.0.0",
    "django-environ>=0.11.0",
    "psycopg[binary]>=3.1.0",
    "gunicorn>=21.2.0",
]

[project.optional-dependencies]
dev = [
    "django-debug-toolbar>=4.3.0",
    "pytest-django>=4.8.0",
    "ruff>=0.2.0",
]
```

--------------------------------

### Helm Test Hook Example (templates/tests/test-connection.yaml)

Source: https://github.com/wshobson/agents/blob/main/plugins/kubernetes-operations/skills/helm-chart-scaffolding/SKILL.md

Defines a Helm test hook as a Kubernetes Pod. This hook runs after the chart is installed to verify its functionality, such as checking network connectivity to a service. It uses `wget` to attempt connecting to the specified service and port.

```yaml
# templates/tests/test-connection.yaml
apiVersion: v1
kind: Pod
metadata:
  name: "{{ include "my-app.fullname" . }}-test-connection"
  annotations:
    "helm.sh/hook": test
spec:
  containers:
  - name: wget
    image: busybox
    command: ['wget']
    args: ['{{ include "my-app.fullname" . }}:{{ .Values.service.port }}']
  restartPolicy: Never
```

--------------------------------

### Install Plugins

Source: https://github.com/wshobson/agents/blob/main/README.md

Install specific development, infrastructure, or orchestration plugins to load their associated agents and tools.

```bash
# Essential development plugins
/plugin install python-development          # Python with 16 specialized skills
/plugin install javascript-typescript       # JS/TS with 4 specialized skills
/plugin install backend-development         # Backend APIs with 3 architecture skills

# Infrastructure & operations
/plugin install kubernetes-operations       # K8s with 4 deployment skills
/plugin install cloud-infrastructure        # AWS/Azure/GCP with 4 cloud skills

# Security & quality
/plugin install security-scanning           # SAST with security skill
/plugin install comprehensive-review       # Multi-perspective code analysis

# Full-stack orchestration
/plugin install full-stack-orchestration   # Multi-agent workflows
```

--------------------------------

### Setup and Test Development Environment with Bash

Source: https://github.com/wshobson/agents/blob/main/plugins/code-documentation/commands/doc-generate.md

Provides a series of shell commands to clone the repository, initialize a Python virtual environment, install dependencies, and execute tests using pytest.

```bash
# Installation using pip
pip install ${PACKAGE_NAME}

# From source
git clone https://github.com/${GITHUB_ORG}/${REPO_NAME}.git
cd ${REPO_NAME}
pip install -e .

# Development setup
python -m venv venv
source venv/bin/activate
pip install -r requirements-dev.txt

# Testing
pytest
pytest --cov=your_package

# Run server
python manage.py runserver
```

--------------------------------

### Install javascript-typescript Plugin

Source: https://github.com/wshobson/agents/blob/main/docs/plugins.md

Install the javascript-typescript plugin for Next.js, React + Vite, and Node.js project setup with pnpm and TypeScript.

```bash
/plugin install javascript-typescript
```

--------------------------------

### Install Plugin Command

Source: https://github.com/wshobson/agents/blob/main/docs/plugins.md

Use this command to install a specific plugin from the wshobson/agents marketplace. Replace 'plugin-name' with the desired plugin identifier.

```bash
/plugin install business-analytics
```

```bash
/plugin install hr-legal-compliance
```

```bash
/plugin install customer-sales-automation
```

```bash
/plugin install python-development
```

```bash
/plugin install javascript-typescript
```

```bash
/plugin install systems-programming
```

```bash
/plugin install jvm-languages
```

```bash
/plugin install web-scripting
```

```bash
/plugin install functional-programming
```

```bash
/plugin install arm-cortex-microcontrollers
```

```bash
/plugin install blockchain-web3
```

```bash
/plugin install quantitative-trading
```

```bash
/plugin install payment-processing
```

```bash
/plugin install game-development
```

```bash
/plugin install accessibility-compliance
```

```bash
/plugin install meigen-ai-design
```

--------------------------------

### LangGraph RAG Quick Start

Source: https://github.com/wshobson/agents/blob/main/plugins/llm-application-dev/skills/rag-implementation/SKILL.md

A Python example demonstrating a basic RAG implementation using LangGraph. It initializes components like LLM, embeddings, and a vector store, then defines nodes for retrieval and generation to build a RAG graph. This snippet requires langchain-anthropic, langchain-voyageai, langchain-pinecone, and langgraph libraries.

```python
from langgraph.graph import StateGraph, START, END
from langchain_anthropic import ChatAnthropic
from langchain_voyageai import VoyageAIEmbeddings
from langchain_pinecone import PineconeVectorStore
from langchain_core.documents import Document
from langchain_core.prompts import ChatPromptTemplate
from langchain_text_splitters import RecursiveCharacterTextSplitter
from typing import TypedDict, Annotated

class RAGState(TypedDict):
    question: str
    context: list[Document]
    answer: str

# Initialize components
llm = ChatAnthropic(model="claude-sonnet-4-6")
embeddings = VoyageAIEmbeddings(model="voyage-3-large")
vectorstore = PineconeVectorStore(index_name="docs", embedding=embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# RAG prompt
rag_prompt = ChatPromptTemplate.from_template(
    """Answer based on the context below. If you cannot answer, say so.

    Context:
    {context}

    Question: {question}

    Answer:"""
)

async def retrieve(state: RAGState) -> RAGState:
    """Retrieve relevant documents."""
    docs = await retriever.ainvoke(state["question"])
    return {"context": docs}

async def generate(state: RAGState) -> RAGState:
    """Generate answer from context."""
    context_text = "\n\n".join(doc.page_content for doc in state["context"])
    messages = rag_prompt.format_messages(
        context=context_text,
        question=state["question"])
    response = await llm.ainvoke(messages)
    return {"answer": response.content}

# Build RAG graph
builder = StateGraph(RAGState)
builder.add_node("retrieve", retrieve)
builder.add_node("generate", generate)
builder.add_edge(START, "retrieve")
builder.add_edge("retrieve", "generate")
builder.add_edge("generate", END)

rag_chain = builder.compile()

# Use
# result = await rag_chain.ainvoke({"question": "What are the main features?"})
# print(result["answer"])

```

--------------------------------

### Initialize Project with pnpm

Source: https://github.com/wshobson/agents/blob/main/plugins/javascript-typescript/commands/typescript-scaffold.md

Commands to install pnpm, initialize a new directory, and configure basic git tracking with standard ignore patterns.

```bash
npm install -g pnpm
mkdir project-name && cd project-name
pnpm init
git init
echo "node_modules/" >> .gitignore
echo "dist/" >> .gitignore
echo ".env" >> .gitignore
```

--------------------------------

### Initialize a New Python Project with uv

Source: https://github.com/wshobson/agents/blob/main/plugins/python-development/skills/uv-package-manager/SKILL.md

Create a new Python project directory and initialize it with uv. This command sets up essential project files like .python-version, pyproject.toml, README.md, and .gitignore.

```bash
# Create new project with virtual environment
uv init my-project
cd my-project

# Or create in current directory
uv init .

# Initialize creates:
# - .python-version (Python version)
# - pyproject.toml (project config)
# - README.md
# - .gitignore
```

--------------------------------

### Adaptive Example Count Selector (Python)

Source: https://github.com/wshobson/agents/blob/main/plugins/llm-application-dev/skills/prompt-engineering-patterns/references/few-shot-learning.md

Dynamically adjusts the number of examples selected based on query and confidence. It iteratively selects more examples until a confidence threshold is met or the maximum number of examples is reached. No external dependencies are explicitly mentioned.

```python
class AdaptiveExampleSelector:
    def __init__(self, examples):
        self.examples = examples

    def select(self, query, max_examples=5):
        # Start with 1 example
        for k in range(1, max_examples + 1):
            selected = self.get_top_k(query, k)

            # Quick confidence check (could use a lightweight model)
            if self.estimated_confidence(query, selected) > 0.9:
                return selected

        return selected  # Return max_examples if never confident enough
```

--------------------------------

### Project README and User Guide Templates

Source: https://github.com/wshobson/agents/blob/main/plugins/code-documentation/commands/doc-generate.md

Standardized Markdown templates for project documentation, covering features, installation prerequisites, environment variables, and end-user troubleshooting guides.

```markdown
# ${PROJECT_NAME}

${SHORT_DESCRIPTION}

## Features
${FEATURES_LIST}

## Configuration
| Variable     | Description                  | Default | Required |
| ------------ | ---------------------------- | ------- | -------- |
| DATABASE_URL | PostgreSQL connection string | -       | Yes      |
| REDIS_URL    | Redis connection string      | -       | Yes      |

## User Guide
### Troubleshooting
| Error               | Meaning                 | Solution        |
| ------------------- | ----------------------- | --------------- |
| "Name required"     | The name field is empty | Enter a name    |
| "Server error"      | Technical issue         | Try again later |
```

--------------------------------

### Apply Few-Shot Learning Patterns

Source: https://github.com/wshobson/agents/blob/main/plugins/llm-application-dev/commands/prompt-optimize.md

Provides a template for incorporating examples, including edge cases and negative examples, to guide model behavior.

```python
few_shot = """
Example 1 (Simple case):
Input: {simple_input}
Output: {simple_output}

Example 2 (Edge case):
Input: {complex_input}
Output: {complex_output}

Example 3 (Error case - what NOT to do):
Wrong: {wrong_approach}
Correct: {correct_output}

Now apply to: {actual_input}
"""
```

--------------------------------

### Install backend-development Plugin

Source: https://github.com/wshobson/agents/blob/main/docs/plugins.md

Install the backend-development plugin for designing RESTful and GraphQL APIs with test-driven development.

```bash
/plugin install backend-development
```
Tokens:
Raw