outbound-builder-plugin

Outbound Builder Plugin

A development plugin for Claude Code. Install this plugin and gain production-tested expertise in Trigger.dev, Drizzle ORM, PostgreSQL, Axiom observability, API client patterns, data viewers, LLM integration, caching, and more.

The plugin packages 24 implementation docs, 25 code templates, 8 skills, and 1 architecture agent into a self-contained knowledge base that any Claude Code session can use to build systems from scratch or improve existing ones.

What's Included

• 24 implementation docs (imp_doc/) -- Architecture patterns, schema design, API client patterns, error handling, config conventions, data viewers, caching, concurrency, testing, LLM integration, and more.
• 25 code templates (templates/) -- Production-tested starter files for schemas, configs, API clients, tasks, orchestrators, rate limiting, bulk operations, deduplication, caching, data viewers, MCP servers, and more.
• 8 skills -- 1 discovery + 1 onboarding wizard + 4 scaffold generators + 1 browser skill + 1 memory skill.
• 1 agent -- Architecture advisor for design questions across all technology domains.
• SessionStart hook -- Automatically runs project discovery on first install, then checks for configuration on subsequent sessions.

Installation

Quick Install (2 commands)

claude plugin marketplace add https://github.com/ankit4479/outbound-builder-plugin
claude plugin install outbound-builder-plugin@outbound-builder

Already added the marketplace?

claude plugin marketplace update outbound-builder
claude plugin install outbound-builder-plugin@outbound-builder

Session-only (for testing)

claude --plugin-dir /path/to/outbound-builder-plugin

After installation, start a new Claude Code session. The SessionStart hook will automatically run project discovery -- analyzing your existing code or interviewing you about a new project -- to map the plugin's knowledge to your specific needs.

Discovery (Automatic)

On first session after install, the plugin automatically runs discovery:

• Existing project: Scans your code (package.json, src/, trigger/, schema, API clients) and identifies which technology domains are relevant. Presents a capability mapping with gaps and a build roadmap.
• Greenfield project: Conducts a focused interview (one question at a time) covering what you're building, external APIs, background jobs, database needs, observability, data viewer, and LLM integration.

Discovery writes .outbound-builder-plugin-discovery.json with the full project profile and build roadmap.

You can also run discovery manually:

/outbound-builder-plugin:discover

Onboarding

After discovery, run the onboarding wizard to configure credentials:

/outbound-builder-plugin:onboard

If discovery results exist, the wizard pre-fills known answers so you can skip redundant questions and go straight to configuring infrastructure credentials.

The wizard walks you through:

1. Project Info -- Project name, description, starting point
2. Core Infrastructure -- DATABASE_URL, Trigger.dev keys, LLM provider + API keys
3. External APIs -- API keys for your specific integrations
4. Observability -- Axiom, Discord alerts, GitHub issue creation (optional)

After the interview, the wizard creates:

• .outbound-builder-plugin-config.json -- Project configuration
• .env -- All collected credentials (gitignored)
• .env.example -- Same keys with placeholder values (safe to commit)

Quick Start

# 1. Install the plugin (see Installation above)
claude plugin install outbound-builder-plugin@outbound-builder

# 2. Start a session -- discovery runs automatically on first launch
#    (or run manually: /outbound-builder-plugin:discover)

# 3. Run onboarding (first time only -- pre-filled from discovery)
/outbound-builder-plugin:onboard

# 4. Scaffold a new project
/outbound-builder-plugin:scaffold-project my-project

# 5. Add your first API client
/outbound-builder-plugin:scaffold-client my-data-api

# 6. Add your first background task
/outbound-builder-plugin:scaffold-task fetch-data

# 7. Ask the architecture advisor for help
# Use the architecture-advisor agent for design questions

Technology Domains

The plugin organizes knowledge by technology domain. Each domain includes implementation docs, code templates, and proven patterns:

Directory Structure

outbound-builder-plugin/
├── .claude-plugin/
│   └── plugin.json                  -- Plugin metadata (name, version, description)
├── CLAUDE.md                        -- Plugin instruction card for Claude
├── README.md
├── hooks/
│   └── hooks.json                   -- SessionStart hook (config validation)
├── scripts/
│   └── check-config.sh      -- Hook script (checks .outbound-builder-plugin-config.json)
├── imp_doc/                         -- Implementation reference documents (24 files)
│   ├── trigger-dev/
│   │   ├── task-patterns.md         -- Trigger.dev task patterns (batch, convergence, status gates)
│   │   ├── orchestration.md         -- Orchestration patterns (round-based, fan-out, unified)
│   │   ├── deployment.md            -- Deployment, versioning, monitoring
│   │   ├── troubleshooting.md       -- Common issues and fixes
│   │   └── pipeline-config.md       -- Rate limits, batch sizes, convergence parameters
│   ├── database/
│   │   ├── schema-patterns.md       -- Schema design patterns, indexes, column conventions
│   │   ├── bulk-operations.md       -- Bulk write patterns (UNNEST)
│   │   ├── bulk-write-advanced.md   -- Advanced UNNEST, conflict handling
│   │   ├── concurrent-access.md     -- Advisory locks, optimistic concurrency
│   │   └── conventions.md           -- NULL handling, status gates, formatting
│   ├── api-clients/
│   │   ├── patterns.md              -- API client patterns, rate limiting, MCP integration
│   │   ├── error-patterns.md        -- Common failures and recovery strategies
│   │   └── error-recovery.md        -- Stale reset, retry tiers, dead-letter patterns
│   ├── observability/
│   │   ├── axiom-queries.md         -- Axiom APL query examples
│   │   └── status-monitoring.md     -- Status monitoring SQL queries
│   ├── caching/
│   │   └── architecture.md          -- Cache TTL, invalidation, completeness checks
│   ├── llm/
│   │   └── integration-patterns.md  -- LLM integration, prompt management, BAML
│   ├── data-viewer/
│   │   └── patterns.md              -- Data viewer server, query builder, AG Grid
│   ├── testing/
│   │   └── patterns.md              -- Schema drift, integration tests, mocking
│   ├── security/
│   │   └── environment.md           -- Environment variables, secrets, SSL config
│   ├── getting-started/
│   │   ├── setup.md                 -- Project bootstrap guide
│   │   ├── entity-processing.md     -- Atomic per-entity processing
│   │   ├── implementation-guide.md  -- Phased build order with milestones
│   │   └── url-deduplication.md     -- URL normalization and dedup
│   └── _archived/                   -- Pipeline-specific docs (historical reference)
├── templates/                       -- Code templates (25 files)
│   ├── drizzle-schema.ts            -- Base Drizzle ORM table definitions
│   ├── pipeline-config.ts           -- Rate limits, batch sizes, defaults
│   ├── trigger-config.ts            -- Trigger.dev project configuration
│   ├── base-api-client.ts           -- API client with rate limiting + retry
│   ├── trigger-task.ts              -- Batch processing task template
│   ├── orchestrator.ts              -- Convergence loop orchestrator
│   ├── rate-limiter.ts              -- Dual-layer rate limiter
│   ├── pipeline-run.ts              -- Pipeline run tracking
│   ├── cache-config.ts              -- Cache TTL + completeness validation
│   ├── process-entity.ts            -- Per-entity atomic processing
│   ├── bulk-upsert.ts              -- UNNEST bulk insert/upsert
│   ├── dedup.ts                    -- Within-batch deduplication
│   ├── stale-recovery.ts           -- Reset stuck entities
│   ├── data-viewer-server.ts        -- Hono data viewer server
│   ├── query-builder.ts            -- Paginated query builder + LRU cache
│   ├── column-defs.ts              -- ColumnDef + schema-to-grid mapping
│   ├── viewer-route.ts             -- Hono route template
│   ├── shared.js                   -- Data viewer frontend framework
│   ├── shared.css                  -- Dark theme design system
│   ├── data-viewer-dashboard.html  -- Dashboard landing page
│   ├── data-viewer-page.html       -- Generic table viewer (AG Grid)
│   ├── schema-drift-test.ts        -- ORM vs live DB comparison test
│   ├── mcp-server.js               -- Custom MCP server template
│   ├── mcp-config.json             -- .mcp.json config patterns
│   └── setup-mcp.sh               -- MCP setup script
├── skills/
│   ├── discover/SKILL.md            -- Automatic project discovery
│   ├── onboard/SKILL.md             -- Interactive setup wizard
│   ├── scaffold-project/SKILL.md    -- Bootstrap a new project
│   ├── scaffold-task/SKILL.md       -- Add a new Trigger.dev background task
│   ├── scaffold-client/SKILL.md     -- Add a new API client
│   ├── scaffold-viewer/SKILL.md     -- Add a data viewer page
│   ├── browse/SKILL.md             -- Browser automation via DOM
│   └── remember/SKILL.md            -- Record/view build-time memory
└── agents/
    └── architecture-advisor.md      -- Architecture expert across all domains

Implementation Documents

Skills

Agent

Build-Time Memory

The plugin includes a build-time memory system (.outbound-builder-plugin-memory.json) that captures development learnings across sessions.

How it works:

• When you scaffold tasks, fix errors, or discover API quirks, the plugin records what you learned
• Each learning is categorized: error-fix, api-quirk, schema-pattern, config-gotcha, build-pattern, domain-insight
• Entries deduplicate by a deterministic ID (hash of category + title)
• At success_count >= 2, a learning becomes a proven pattern
• Proven patterns are injected at every session start via the SessionStart hook

Usage:

# Record a learning manually
/outbound-builder-plugin:remember "Drizzle push needs SSL disabled for Neon"

# View all learnings and proven patterns
/outbound-builder-plugin:remember show

Scaffold skills automatically record learnings after each run when errors or workarounds were encountered.