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 sparkdeath324 with your GitHub org/user in both the commands above and the REPO_URL at the top of install.sh before publishing.

Upgrade: cd ~/.forge && git pull && ./install.sh (idempotent). Uninstall: rm -rf ~/.claude/skills/forge.

Use

1. 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).
2. Enter plan mode.
3. 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.