TT-Wang/forge

Turn Claude Code into a structured delivery loop: plan the work, run modules in parallel, validate deeply, retry intelligently, and carry forward what worked.
Why Forge
Single-agent Claude Code drifts past ~5 steps. The failure mode isn't code quality — it's **silent state corruption**: parallel workers branching from stale HEAD, modules quietly clobbering each other's changes, "DONE" status that hides broken integration. Forge externalizes the **plan → execute → validate** loop so the same task that would silently break at 7 steps cleanly delivers at 30.
**Core mechanic:**
- **DAG plans, not linear chains** — workers run in parallel where dependencies allow
- **Worktree isolation + auto-WIP commits between tiers** — every tier writes to disk before the next branches off (this exists because we shipped memem v0.10.0 once with this exact failure: 20 min of recovery work)
- **Per-module verify commands & acceptance criteria** — defined at plan time so workers can't quietly lower the bar
- **Multi-lens review** — a separate reviewer agent + 3× self-consistency catches cross-module bugs single-module reviewers miss
- **Structured failure ledger** — failure modes captured as JSONL, recalled by pattern ID in the next plan
**Track record:** shipped memem v1.7 → v1.8.3 (7 releases) in a single day, including a 9-file anti-recursion safety fix and a persistent slice daemon — with human in the loop only at yes/modify/abort gates.
Install
Copy-paste:
First start may take a few seconds because Forge bootstraps its MCP server dependencies automatically.
After install:
1. restart Claude Code if it was already open
2. open any repo you want to work in
3. run /forge
Example:
The Pitch
Forge is for the point where plain prompting stops being enough.
If the task touches several files, needs coordination between modules, or needs proof that it actually works, Forge gives Claude Code a workflow instead of just another prompt:
- break the work into modules
- run what can be parallelized
- validate each module hard
- retry failures with debugger context
- remember what worked for the next task
You still use Claude Code. Forge just adds structure around the hard parts.
What You Get
- **Structured planning**: breaks a feature into modules with dependencies and verification commands
- **Parallel execution**: runs independent modules at the same time in isolated worktrees
- **Deep validation**: checks files, commands, syntax, and cross-module API contracts
- **Intelligent retry**: tracks attempts, detects stagnation, and escalates to a debugger agent
- **Session resumability**: picks up incomplete work instead of starting from scratch
- **Cross-session memory**: remembers conventions, failure patterns, and test commands
- **Status visibility**: exposes progress in Claude output and a terminal status line
Why Not Just Use Claude Code Directly?
For many tasks, you should.
| Task shape | Plain Claude Code | Forge |
|---|---|---|
| One small edit | Better | Overkill |
| Quick investigation | Better | Overkill |
| Multi-file feature | Manual coordination required | Strong fit |
| Parallelizable work | You manage it yourself | Built in |
| Deep validation | You remember to run it | Part of the workflow |