Usage Guide

Complete guide to all 15 Forge DevKit modules — what they do, how to use them, and why they matter.

All commands run inside your AI session (Claude Code, Cursor, or Claude Desktop). Forge DevKit is a plugin system — commands become available after installation.

Core Pipeline

7 modules

The development backbone. These modules power the setup wizard, development pipeline, testing, task tracking, parallel execution, and branch isolation.

forge-core

Starter+

The foundation. One command makes your AI understand your entire project.

forge-core runs a 7-gate architecture audit that auto-detects your stack, layers, conventions, and patterns. It generates project-specific dev-skills and 50+ quality guardrails that your AI follows in every session. The universal Hub classifies your intent, walks the dependency graph, and routes to the right pipeline - so you never need to memorize commands or worry about missing prerequisites.

Without Forge: you spend 20 minutes every session re-explaining your architecture to AI. It forgets your NestJS guards, your layer conventions, your naming patterns - every single time.
With forge-core: one /forge:setup and your AI permanently knows your stack, layers, and conventions. No manual prompt engineering. No re-explaining. Ever.

What you get

  • Universal Hub: describe what you want in plain English - no commands to memorize, no prerequisites to miss
  • Auto-detects stack, architecture patterns, and conventions
  • Generates 50+ quality patterns tailored to your project
  • Creates project-specific dev-skills your AI loads automatically
  • Scoped pipeline phases prevent AI from going off-track
  • 15 LLM rationalization detectors catch AI shortcuts
/forge:setup Setup wizard, ecosystem dashboard, upgrade, and reconfigure.
/forge:setup Run the 7-gate wizard (first time) or show the ecosystem dashboard (after setup)
/forge:setup upgrade --check Check for plugin updates
/forge:setup upgrade Apply available updates
/forge:setup reconfigure Re-run specific gates without full setup
/forge:hub Universal entry point - classifies intent, resolves prerequisites, executes the right pipeline.
/forge:hub "add payment system" Describe what you want - Hub classifies intent, walks dependency graph, builds execution chain
/forge:hub "fix login bug" Direct routing - bug fixes skip prerequisites and go straight to /dev
/forge:hub "run SEO audit" Non-dev intents route to the right module without touching the dev pipeline
/forge:patch Quick config patches without running the full wizard.
/forge:patch Interactive patch mode - select what to adjust
/dev Start a development task using the generated pipeline. Hub routes here automatically for implementation work.
/dev Begin a feature/fix using your project's dev-skills and quality patterns
/forge:sync Sync generated artifacts after architecture changes
/forge:close Finalize and close the current development task

Typical workflow: Install → /forge:setup (7-gate audit) → /forge:hub to start any task. Hub resolves prerequisites and routes to /dev, /forge:qa, or other modules automatically.

forge-product

Pro+

Describe features in business language. AI builds from spec, not guesswork.

forge-product bridges the gap between what you want and what AI builds. Describe a feature in plain language - it generates user flows, user stories with acceptance criteria, and UX specifications. These artifacts feed directly into the development pipeline, so your AI codes from verified requirements instead of hallucinated assumptions.

Without Forge: you describe a feature vaguely, AI hallucinates requirements, builds the wrong thing, and you spend hours debugging assumptions that were never verified.
With forge-product: describe features in business language - AI generates verified user flows, stories, and acceptance criteria before writing a single line of code.

What you get

  • 9 product archetypes (SaaS, marketplace, API platform, etc.)
  • Generates user flows, stories, and acceptance criteria automatically
  • 50+ UX criteria library for consistent quality
  • Stories feed directly into /dev pipeline - zero copy-paste
  • Supports multiple methodologies (Lean, Jobs-to-be-Done, etc.)
/forge:product-setup Configure product design module - select archetype, methodology, integrations.
/forge:product-setup Interactive setup wizard for product module
/forge:product Product design operations - features, epics, roadmap, strategy.
/forge:product design Design a feature with user flows, stories, and acceptance criteria
/forge:product epic Create an epic with breakdown into stories
/forge:product roadmap Generate or update a product roadmap
/forge:product strategy Define or refine product strategy (positioning, ICP, GTM)

Typical workflow: /forge:product-setup → /forge:product design for each feature → stories feed into /dev pipeline.

forge-qa

Pro+

Tests that trace back to requirements. Not AI guesswork.

forge-qa generates tests from acceptance criteria, not from AI assumptions. It supports 10 testing modes and maintains a 4-level traceability matrix: acceptance criteria → unit tests, use cases → E2E tests, UX criteria → visual tests, and LLM-as-Judge for AI output quality. Every test proves a requirement - no orphan tests, no missing coverage.

Without Forge: AI generates tests with 100% coverage - all using mock data. Every assertion tests implementation details. Zero real behavior verified.
With forge-qa: every test traces back to an acceptance criterion. No orphan tests. No missing coverage. Tests prove requirements, not AI guesswork.

What you get

  • Generates tests from acceptance criteria - not guesswork
  • 4-level traceability: AC → unit, UC → E2E, UX → visual, Judge
  • 10 testing modes for different scenarios
  • LLM-as-Judge evaluates AI-generated output quality
  • Quality gates block merges until requirements are covered
/forge:qa-setup Configure QA module - select test frameworks, coverage thresholds, traceability level.
/forge:qa-setup Interactive QA configuration wizard
/forge:qa Test operations - generation, coverage analysis, quality gates.
/forge:qa generate Generate tests from acceptance criteria or user stories
/forge:qa coverage Analyze test coverage and suggest missing tests
/forge:qa trace Show traceability matrix (AC → test → code)
/forge:qa judge Run LLM-as-Judge to evaluate test quality
/forge:qa gate Run quality gate checks before merge

Typical workflow: /forge:qa-setup → /forge:product design (generates AC) → /forge:qa generate → /forge:qa gate before merge.

forge-tracker

Pro+

Your backlog lives in your tracker. Now your AI reads it too.

forge-tracker connects your existing task management tool to the AI development pipeline. Pick a task from GitHub Issues, Linear, ClickUp, Notion, or Jira - your AI gets the full context (description, acceptance criteria, labels, priority) and starts working. When done, it syncs status and links the PR back to the task. No more copy-pasting issue descriptions into prompts.

Without Forge: you copy-paste issue descriptions from your tracker into AI prompts. Context gets lost. Status updates are manual. PRs never link back to tasks.
With forge-tracker: /forge:tracker pick pulls the task with full context. When you're done, /forge:tracker close syncs status and links the PR - zero manual updates.

What you get

  • 5 integrations: GitHub Issues, Linear, ClickUp, Notion, Jira
  • Pick tasks directly from your tracker - AI gets full context
  • Auto-syncs task status and progress back to tracker
  • Links PRs and commits to tasks automatically
  • AC validation ensures task requirements are met before closing
/forge:tracker-setup Configure task tracker integration - select provider and connect.
/forge:tracker-setup Interactive tracker setup (auto-detects available integrations)
/forge:tracker Task management operations - pick, sync, close tasks.
/forge:tracker pick Pick a task from your tracker to work on
/forge:tracker sync Sync task status and progress back to tracker
/forge:tracker close Close task with summary and link to PR/commit

Typical workflow: /forge:tracker-setup → /forge:tracker pick → /dev → /forge:tracker sync → /forge:tracker close.

forge-prompts

Pro+

Your AI prompts are code. Manage them like code.

forge-prompts brings software engineering rigor to prompt management. It inventories every LLM prompt in your project, audits them against provider-specific best practices, and tracks quality over time. Three frameworks (CO-STAR, RISEN, TIDD-EC) guide structured prompt design. A dedicated subagent handles prompt writing and refactoring - so your prompts evolve as your product grows.

Why manage prompts? AI-powered apps ship dozens of LLM prompts. Without inventory and auditing, prompts rot as your codebase evolves - leading to degraded AI output that's hard to trace back to a stale system prompt.

What you get

  • Auto-inventories all LLM prompts across your codebase
  • Provider-aware auditing (Anthropic, OpenAI, generic)
  • 3 structured frameworks: CO-STAR, RISEN, TIDD-EC
  • Dedicated prompt-engineer subagent for writing and refactoring
  • Learning loop captures prompt patterns from your project
/forge:prompts-setup Configure prompt architecture, principles, and provider settings.
/forge:prompts-setup 3-gate wizard: LLM detection, prompt architecture, principles
/forge:prompts Prompt engineering operations - inventory, audit, review, test, evolve.
/forge:prompts inventory Scan codebase and list all LLM prompts with metadata
/forge:prompts audit Audit prompts against provider best practices
/forge:prompts review Deep review of a specific prompt with improvement suggestions
/forge:prompts test Test prompt with sample inputs, evaluate output quality
/forge:prompts evolve Apply learning loop - capture patterns, update principles

Typical workflow: /forge:prompts-setup → /forge:prompts inventory → audit → fix issues → /forge:prompts evolve.

forge-autopilot

Complete

Run 3 agents in parallel. Zero merge conflicts.

forge-autopilot orchestrates autonomous AI teammates like Kubernetes orchestrates containers. Give it a list of features - it triages them, detects potential conflicts (shared models, overlapping files), groups non-conflicting features into parallel waves, and deploys agents to isolated worktrees. Each agent follows your full pipeline (guardrails, tests, quality gates). When a wave completes, it auto-merges and starts the next wave.

Without Forge: you run 3 agents in parallel - they all edit the same User model. You spend 4 hours resolving merge conflicts. Net productivity: negative.
With forge-autopilot: conflict detection groups features into safe waves. Each agent gets an isolated worktree with your full pipeline. Auto-merge after quality gates pass.

What you get

  • Backlog triage classifies features by complexity and risk
  • Conflict detection prevents agents from editing the same files
  • Wave execution runs non-conflicting features in parallel
  • 3 autonomy modes: supervised, semi-auto, full-auto
  • Auto-merge with quality gate verification before merge
/forge:autopilot Launch batch autonomous development pipeline.
/forge:autopilot --setup Configure autonomy mode and feature sources
/forge:autopilot Start batch with configured sources (triage → waves → execute)
/forge:autopilot "auth, payments" Start batch with specific features
/forge:autopilot --resume Resume interrupted batch from last checkpoint
/forge:autopilot --abort Abort current batch and clean up worktrees

Typical workflow: /forge:autopilot --setup → /forge:autopilot → agents triage, detect conflicts, execute in waves → review results.

forge-worktree

Starter+

Isolated branches with zero port conflicts. Automatic cleanup.

forge-worktree manages the git worktree lifecycle for parallel development. Each worktree gets its own directory, Docker port offsets, and environment configuration - no more port conflicts between branches. Three templates cover common setups: Docker backend (with port isolation), Frontend (with dev server offsets), and Generic. Worktrees are auto-provisioned by forge-autopilot or created manually.

Why worktrees? Each Agent Teams teammate needs isolation - its own branch, ports, and environment. Manual setup is error-prone. forge-worktree automates the entire lifecycle, so you focus on features, not infrastructure.

What you get

  • 3 templates: Docker backend, Frontend, Generic
  • Automatic Docker port isolation per worktree
  • Auto-cleanup when branches are merged
  • Integrates with forge-autopilot for autonomous provisioning
  • Zero manual configuration for environment isolation
/forge:worktree-setup Configure worktree templates and isolation settings.
/forge:worktree-setup Interactive worktree configuration - select template (Docker backend, Frontend, Generic)

Typical workflow: /forge:worktree-setup → worktrees are auto-provisioned by forge-autopilot or created manually via git worktree.

Advisory Modules

8 modules

Strategic advisors that surround the core pipeline. Each module generates planning artifacts, audits, and recommendations - from discovery and marketing to SEO, analytics, and growth. Available in the Complete plan.

How advisory modules work: They read artifacts from the core pipeline (user flows, acceptance criteria, product strategy) and generate domain-specific outputs. Each module connects to others through shared state - forge-marketing reads forge-discovery results, forge-copy reads forge-marketing positioning, and so on. Install one or install all - each works standalone but gets smarter with context from its neighbors.

forge-discovery

Complete

Validate before you build. Research before you commit.

forge-discovery structures the messy early phase of product development. Instead of jumping to code, it guides you through ideation, competitive research, problem validation, and user interview planning. The output feeds directly into forge-product - so by the time you design features, you have validated assumptions, not guesses.

What you get

  • Guided ideation with structured brainstorming frameworks
  • Competitive research with positioning analysis
  • Problem validation before committing to solutions
  • User interview script generation for qualitative research
  • Discovery artifacts feed directly into forge-product
/forge:discovery-setup Configure discovery scope and research methodology.
/forge:discovery-setup Setup wizard - define scope, target market, research approach
/forge:discovery Product discovery operations - ideate, research, validate, interview.
/forge:discovery ideate Structured brainstorming from raw idea to opportunity map
/forge:discovery research Competitive analysis and market research
/forge:discovery validate Problem validation with evidence-based scoring
/forge:discovery interview Generate user interview scripts and analysis frameworks

Typical workflow: /forge:discovery-setup → ideate → research → validate → feed results into /forge:product.

forge-marketing

Complete

From validated problem to sellable product. Strategy, not guesswork.

forge-marketing turns your validated product insights into marketing strategy. It generates positioning, pricing recommendations, go-to-market plans, and content calendars - all grounded in your product data, not generic templates. When forge-discovery and forge-product are installed, it reads their artifacts automatically for context-aware recommendations.

What you get

  • Positioning framework tailored to your product and market
  • Data-driven pricing with competitive context
  • Go-to-market plan with channel strategy and timeline
  • Content calendar aligned with product milestones
  • Reads discovery and product artifacts for context-aware output
/forge:marketing-setup Configure marketing scope and strategy parameters.
/forge:marketing-setup Setup wizard - define market, channels, budget constraints
/forge:marketing Marketing operations - positioning, pricing, GTM, content.
/forge:marketing position Generate positioning and messaging framework
/forge:marketing price Pricing strategy with tier design and competitive analysis
/forge:marketing launch Go-to-market plan with timeline and channel strategy
/forge:marketing content Content calendar aligned with product roadmap

Typical workflow: /forge:marketing-setup → position → price → launch plan → content calendar.

forge-copy

Complete

Consistent voice across every screen, email, and notification.

forge-copy manages production copy as a first-class concern. Define your brand voice once - it generates and reviews UI microcopy, email templates, notification text, and error messages against your voice guidelines. When forge-product or forge-marketing are installed, it uses their positioning and user research for copy that speaks your customer's language.

What you get

  • Brand voice configuration with tone and style rules
  • Generates UI microcopy, emails, notifications, error messages
  • Reviews existing copy against brand guidelines
  • Uses product and marketing context for customer-aware copy
  • Consistency checks across all copy touchpoints
/forge:copy-setup Configure brand voice, tone rules, and copy scope.
/forge:copy-setup Setup wizard - define voice, tone, terminology, style rules
/forge:copy Copy operations - generate and review across all contexts.
/forge:copy generate Generate copy for a specific context (UI, email, notification)
/forge:copy review Review existing copy against brand voice guidelines

Typical workflow: /forge:copy-setup → /forge:copy generate for each context → /forge:copy review before release.

forge-seo

Complete

Technical SEO your AI actually understands. Not a checklist - a strategy.

forge-seo combines technical SEO auditing with keyword research and schema markup generation. It scans your pages for issues (missing meta tags, broken structured data, performance bottlenecks), researches keywords aligned with your product positioning, and generates JSON-LD schema markup. When forge-analytics is installed, it correlates SEO metrics with user behavior data.

What you get

  • Technical SEO audit with prioritized fix list
  • Keyword research aligned with product positioning
  • JSON-LD schema markup generation for rich snippets
  • Content gap analysis based on competitor rankings
  • Correlates with analytics data when forge-analytics is installed
/forge:seo-setup Configure SEO scope and target parameters.
/forge:seo-setup Setup wizard - define target pages, keywords, competitors
/forge:seo SEO operations - audit, keywords, schema markup.
/forge:seo audit Technical SEO audit with prioritized issue list
/forge:seo keywords Keyword research with search intent analysis
/forge:seo schema Generate JSON-LD structured data markup

Typical workflow: /forge:seo-setup → /forge:seo audit → fix issues → keywords → schema.

forge-analytics

Complete

Measurement-first. Plan what to track before you ship.

forge-analytics flips the usual approach: instead of adding tracking after launch, you define a measurement plan during development. It generates event schemas, tracking plans, and dashboard specifications before a single line of tracking code is written. Your team knows exactly what data you'll have on day one.

What you get

  • Measurement-first tracking plans defined during development
  • Event schema generation with naming conventions
  • Dashboard specifications ready for implementation
  • Aligned with product artifacts (user flows, acceptance criteria)
  • No post-launch tracking gaps - plan before you ship
/forge:analytics-setup Configure analytics scope and measurement strategy.
/forge:analytics-setup Setup wizard - define key metrics, events, data sources
/forge:analytics Analytics operations - tracking plans, event schemas, dashboards.
/forge:analytics plan Generate measurement plan with KPIs and event taxonomy
/forge:analytics schema Generate event schemas with naming conventions
/forge:analytics dashboard Design dashboard specifications for key metrics

Typical workflow: /forge:analytics-setup → plan → schema → implement tracking → dashboard.

forge-onboarding

Complete

From signup to aha moment. Design the path, not just the page.

forge-onboarding designs activation flows that convert signups into engaged users. It maps the journey from first login to the "aha moment" - the point where users experience core value. Generates step-by-step onboarding flows, empty state designs, tooltip sequences, and progress indicators. When forge-product is installed, it uses user flows and personas to tailor the onboarding path.

What you get

  • Activation flow design from signup to aha moment
  • Empty state and first-run experience specifications
  • Tooltip and guided tour sequence planning
  • Progress indicator and milestone design
  • Audit existing onboarding for drop-off points
/forge:onboarding-setup Configure onboarding scope and activation goals.
/forge:onboarding-setup Setup wizard - define aha moment, activation steps, personas
/forge:onboarding Onboarding design operations - design flows, audit existing experience.
/forge:onboarding design Design activation flow from signup to aha moment
/forge:onboarding audit Audit existing onboarding for friction and drop-off points

Typical workflow: /forge:onboarding-setup → design → implement → /forge:onboarding audit after launch.

forge-growth

Complete

Retain, refer, expand. Three levers, one module.

forge-growth structures the three core growth levers: retention (reduce churn), referral (organic acquisition), and expansion (upsell and cross-sell). It generates churn prevention strategies with cancel flow designs, referral program frameworks, and expansion revenue playbooks. When forge-analytics is installed, it grounds recommendations in actual user behavior data.

What you get

  • Churn prevention with cancel flow and save offer design
  • Referral program framework with incentive modeling
  • Expansion revenue playbook (upsell, cross-sell triggers)
  • Grounded in analytics data when forge-analytics is installed
  • Cohort-based retention analysis recommendations
/forge:growth-setup Configure growth scope and retention goals.
/forge:growth-setup Setup wizard - define growth model, retention targets, referral goals
/forge:growth Growth operations - retention, referral, expansion strategies.
/forge:growth retain Churn prevention strategy with cancel flow design
/forge:growth refer Referral program design with incentive structure
/forge:growth expand Expansion revenue playbook (upsell, cross-sell)

Typical workflow: /forge:growth-setup → retain → refer → expand.

forge-ab

Complete

Statistically valid experiments. Not "we changed the button color."

forge-ab brings statistical rigor to product experimentation. It structures experiments from hypothesis to analysis: defines success metrics, calculates required sample sizes, designs variants, and provides analysis frameworks. No more running tests without enough traffic, or declaring winners based on gut feeling. When forge-analytics is installed, it uses your event schemas for metric definitions.

What you get

  • Structured hypothesis format with measurable outcomes
  • Sample size calculation to avoid underpowered tests
  • Experiment design with variant specifications
  • Statistical analysis framework for interpreting results
  • Uses analytics event schemas for consistent metrics
/forge:ab-setup Configure experiment tracking and analysis settings.
/forge:ab-setup Setup wizard - experiment infrastructure, significance thresholds
/forge:ab A/B experiment operations - hypothesis, design, analyze.
/forge:ab hypothesis Structure experiment hypothesis with success criteria
/forge:ab design Design experiment with variants, metrics, sample size
/forge:ab analyze Analyze results with statistical significance testing

Typical workflow: /forge:ab-setup → hypothesis → design → run experiment → analyze.

Feedback & Bug Reports

Found a bug? Have a suggestion? Use the built-in feedback command — it sends structured reports directly to the Forge team.

/forge:feedback Send feedback, bug reports, or feature requests.
/forge:feedback Interactive feedback wizard — select type (bug, friction, suggestion), describe the issue, auto-attaches session context

The feedback command collects:

  • Your description — what happened, what you expected
  • Session context — plugin versions, detected stack, execution mode (auto-attached, no manual work)
  • Feedback type — friction (something was hard), bug (something broke), suggestion (feature request)

Reports are sent securely using your license key. No source code or file contents are included — only metadata and your description.

Alternatively, email support@reumbra.com for direct support.

Ready to get started?

One-time purchase. 14-day money-back guarantee.

Get Forge →