forge
Turn a one-line idea into a working, full-stack web app — by orchestrating a fleet of parallel agents.
forge is a Claude Code skill. Invoke it in plan mode (ideally with ultracode on) and it will interrogate your idea across every dimension, design the architecture and a distinctive UI, then build, run, and verify the whole app end to end — pausing at checkpoints so you stay in control.
It is self-contained but composes with best-in-class companions when you have
them (superpowers, feature-dev, frontend-design) — and falls back to its own
embedded guidance when you don't.
Install — one paste
Requirements: Claude Code, git, bash.
git clone --depth 1 https://github.com/sparkdeath324/forge.git ~/.forge && ~/.forge/install.sh
Or the curl | bash bootstrap (after you set REPO_URL in install.sh):
curl -fsSL https://raw.githubusercontent.com/sparkdeath324/forge/main/install.sh | bash
That copies the skill to ~/.claude/skills/forge/. Restart Claude Code so it
picks up the new skill.
Replace
sparkdeath324with your GitHub org/user in both the commands above and theREPO_URLat the top ofinstall.shbefore publishing.
Upgrade: cd ~/.forge && git pull && ./install.sh (idempotent).
Uninstall: rm -rf ~/.claude/skills/forge.
Use
- Turn on ultracode (forge is built for heavy multi-agent orchestration; if it's off, the skill explains and offers a lighter single-threaded path).
- Enter plan mode.
- Say what you want, e.g. "build me an app: a personal habit tracker with streaks and a heatmap."
forge then walks these phases:
| Phase | Where | What happens |
|---|---|---|
| A. Gate & Frame | main thread | ultracode check; frame the idea |
| B. Clarify | main thread | questions across every aspect → a written spec |
| C. Architecture + UI | parallel agents | a disjoint slice manifest + design tokens |
| D. Plan | ExitPlanMode | you approve the build plan |
| E. Build | checkpointed Workflow | foundation → parallel slices → integrate → build-run-verify loop, with a checkpoint after each phase |
| F. Report | main thread | how to run it, file map, QA results, gaps, next steps |
The interactive thinking happens up front (only the main thread can ask you questions); once you approve, the build fans out across agents and pauses at checkpoints so you can redirect.
How it works (design notes)
- Parallelism by disjoint file ownership. Architecture is decomposed into independent slices, each owning a strictly disjoint set of files, built against frozen shared contracts. An integrator owns the shared wiring. This is what lets agents build concurrently in one tree — there is no filesystem lock, so the manifest must truly partition every path.
- Main thread vs subagents. Skill-dependent, interactive work (brainstorming, UI direction) runs in the main thread; subagents only do autonomous, fully-specified work (architecture-from-spec, slice builds, verification). Subagents can use agent types but cannot reach skills — so skill expertise is inlined into their briefs.
- Built to actually run. The verify loop installs, builds, tests, boots the app, and smoke-tests the core flows, dispatching fix agents until green or a capped number of rounds — then reports honestly.
Optional: watch the build live
If you run multi-agent-connector,
forge can broadcast each checkpoint so you can follow and steer the build from a
second window. Note it's a handoff bus, not a file lock — it never enforces
slice ownership.
License
MIT — see LICENSE.