forgeplan

ForgePlan

Architecture-governed AI builds. A Claude Code plugin.

/forgeplan:greenfield "A task manager with teams, permissions, and Supabase"
# One confirmation. Walk away. Come back to a certified, runnable codebase.

✓ Discovered: 5 nodes, 2 shared models (MEDIUM tier)
✓ Researched: 12 packages vetted, all MIT
✓ Specced: 47 acceptance criteria across 5 nodes
✓ Built: 38 files, all tests passing
✓ Verified: compiles, tests pass, dev server starts
✓ Reviewed: 5/5 nodes pass 7-dimension spec audit
✓ Swept: 5 agents, 2 passes, 0 findings remaining
✓ Certified. Ready to ship.

What it does

ForgePlan sits between you and your AI-generated code. You describe the architecture once — nodes, boundaries, shared models, acceptance criteria — and the harness enforces it as code gets generated. Writes outside a node's file scope are rejected by a hook. Shared type redefinitions are blocked. Builds don't complete until acceptance criteria are met.

The pipeline: discover → spec → build → verify → review → sweep → certify.

Each step scales to your project. A simple app gets 3 sweep agents and finishes in one session. A complex app gets all 5 agents, cross-model verification, and convergence certification.

Optional design direction can live in DESIGN.md, docs/DESIGN.md, or .forgeplan/wiki/design.md. ForgePlan surfaces those files in session status and feeds them into frontend build/design-pass flows when present. You can also enable bundled design profiles in .forgeplan/config.yaml via design.profiles, add secondary influences with design.mixins, and add synthesis guidance with design.blend_notes. Imported external profiles use the awesome/<slug> namespace, for example awesome/vercel, awesome/linear.app, or awesome/notion.

What you actually do

You:  /forgeplan:greenfield "A task manager with teams, permissions, and Supabase"

      ForgePlan runs autonomously:
      → Architect decomposes into nodes, assesses complexity, picks stack
      → Researcher vets packages, checks licenses, finds patterns

You:  Confirm architecture once. Walk away.

      → Specs all nodes with acceptance criteria
      → Builds each node (skills loaded per node type)
      → Verifies it compiles, tests pass, dev server starts
      → Design pass checks frontend for AI-slop patterns

You:  Optional — "make it darker" / "use green accent" / [enter to skip]

      → Reviews every node against its spec
      → 5 sweep agents audit the full codebase
      → Certifies. Done.

Three interactions: confirm the architecture, steer the design (optional), and pick up your certified app. Everything else is autonomous.

Install

# Claude Code plugin — add via settings, then:
/forgeplan:help

Commands

Start here:

/forgeplan:greenfield [description]    # Idea → certified app (autonomous)
/forgeplan:guide                       # What should I do next?

When you want more control:

/forgeplan:discover                    # Architecture conversation or --from doc.md
/forgeplan:research [topic]            # Package search, license check, patterns
/forgeplan:spec [node|--all]           # Generate enforcement contracts
/forgeplan:build [node|--all]          # Build with file scope + shared model enforcement
/forgeplan:review [node]               # 7-dimension spec-diff audit
/forgeplan:sweep [--cross-check]       # Multi-agent codebase audit
/forgeplan:deep-build                  # Full autonomous pipeline

All 21 commands →

How enforcement works

What	How
File scope	Builder can only write to its node's directory. Hook rejects everything else.
Shared models	Types in the manifest must be imported from canonical source. Local redefinitions blocked.
Shell commands	Only safe commands allowed during builds. Dangerous operations rejected.
Acceptance criteria	Stop hook checks every criterion. Unmet criteria bounce the builder back.
Phase boundaries	Future-phase nodes are locked until current phase completes.

80%+ of enforcement is instant glob matching. LLM-based checks only when needed.

Sweep agents

Five agents audit your code from different angles after every build. All opus.

Agent	Job
Adversary	Tries to break it — injection vectors, false-pass conditions, error handling gaps
Contractualist	Diffs both sides of every boundary — type mismatches, API contract violations, import drift
Pathfinder	Walks every user flow end-to-end — dead-end states, accessibility, test quality
Structuralist	Zooms out — over-engineering, dead code, inconsistent patterns, documentation accuracy
Skeptic	Traces every spec criterion to code — logic bugs, missing implementations, cross-agent gaps