forge

Name: forge
Author: sparkdeath324

Verified

0stars

0forks

Shell

Added 5/29/2026

Installation

# Add to your Claude Code skills
git clone https://github.com/sparkdeath324/forge

Getting Started

Guides for using ai agents skills like forge.

Caveman: Cut Claude Token Use by 65%
How agent-side prompt compression works, when to use it, and when not to.
What is an AI Skills Marketplace?
Definitions, how marketplaces work, and how to choose between them in 2026.
Getting Started with AI Skills

Security ReportVerified

Last scanned: 5/30/2026

{
  "issues": [],
  "status": "PASSED",
  "scannedAt": "2026-05-30T17:06:30.731Z",
  "npmAuditRan": true,
  "pipAuditRan": true
}

README.md

Frequently Asked Questions

What is forge?

forge is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by sparkdeath324. It has 0 GitHub stars.

Is forge safe to use?

Yes. forge passed SkillsLLM's automated security scan — a dependency vulnerability audit plus prompt-injection heuristics — with no high-severity issues. You can read the full report in the Security Report section on this page.

How do I install forge?

Clone the repository with "git clone https://github.com/sparkdeath324/forge" and add it to your Claude Code skills directory (see the Installation section above).

What programming language is forge written in?

forge is primarily written in Shell. It is open-source under sparkdeath324 on GitHub, so you can review or fork the full source.

Are there alternatives to forge?

Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh forge against similar tools.

Agentic AI for Beginners

Build your first AI agent from scratch - tool use, ReAct pattern, memory, deployment

41 minBeginner

Comments (0)

to leave a comment.

No comments yet. Be the first to share your thoughts!

Related Skills

superpowers

by obra

An agentic skills framework & software development methodology that works.

234,966

flue-skills game-prd-builder-skills

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

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.