Forge

Inspiration Most AI tools respond to early-stage ideas with optimistic roadmaps that assume the idea works. Nobody forces you to confront what your idea actually depends on — before you've wasted time finding out the hard way. Forge does the opposite. It finds what your idea depends on, assigns skeptics to pressure-test each dependency, and only builds your execution plan from what survives.

What Forge Does Forge turns a one-sentence idea into a dependency-aware execution plan — by forcing the founder to defend their assumptions before any plan is generated. Every idea is a tree of assumptions. Some are foundational. Some depend on others being true first. Forge makes that structure visible, interactive, and consequential. You don't read a report. You fight for your idea, node by node, and earn your roadmap.

How We Built It Input: One sentence. The user's raw idea. Call 1 — Classification + Personas

Classifies idea type (startup / class project / research / social initiative) and generates 4 domain-specific skeptical personas calibrated to the actual idea. Not generic archetypes — a fintech startup gets a procurement skeptic and a unit economics investor, not a generic "user" and "expert." A rules engine can't do this. Persona generation has to be idea-aware. Call 2 — Assumption Graph

Extracts 5–8 falsifiable assumptions as a DAG — not a flat list. Each node gets a dimension tag (desirability / feasibility / viability), a persona owner, and explicit dependency links. Foundational nodes activate immediately. Dependent nodes stay locked until parents resolve. The Roadmap node sits at the top — it unlocks only when everything beneath it is resolved. Why a DAG? Because "users will pay" depends on "users actually want it." Flattening that into a checklist hides the kill order. User Interaction — Persona Chat

User clicks an active node. Chat opens with the assigned persona. 3 exchanges maximum. The persona is skeptical, specific, and in character throughout. Convinced → green, children unlock. Not convinced after 3 exchanges → red, all descendants collapse to pending. No partial states. No AI-assigned scores. No automated verdicts. Call 3 — Synthesis

Triggered when the user reaches the Roadmap node. Generates an execution plan built only from green assumptions. Red nodes appear explicitly as risks — never papered over. If too many foundational nodes failed, Forge returns a pivot recommendation instead of a false plan. Total call budget: 1 + 1 + N chat turns + 1. All calls triggered by user action. No background polling. Interface: Live 3D graph via react-force-graph-3d. Node positions fixed by layer, colors reflect real-time state. The graph is the UI.

Why LLM, Not Rules Assumption extraction and persona generation require semantic understanding of the specific idea. The same system handles a B2B SaaS, a public health initiative, and a research project — with different personas, different assumptions, different kill orders. A rules engine produces the same four generic roles every time. The LLM reads the actual idea. What AI does NOT do: decide whether an assumption is validated. That is always the human's call.

Responsible AI Risk: users treat green nodes as proof their idea works rather than as decision inputs. Mitigation: full chat history is visible for every node — mentors and teammates can audit exactly how each assumption was resolved. Outputs are framed as decision inputs, not verdicts. Red assumptions stay visible; they are never hidden.

Human-in-the-Loop Forge does not decide whether an assumption is sufficiently defended. The user makes that call through the conversation itself. Only they know what evidence is strong enough to move forward. Automating this would produce false confidence — which is exactly the problem we're solving.

Tools Used

Groq API + LLaMA 3 — all LLM calls (free tier) FastAPI — backend (open source, free) React + react-force-graph-3d — frontend (open source, free) Claude by Anthropic — coding assistance during development (disclosed)

Data Sources No external datasets. All inputs are user-generated. Personas, assumptions, and execution plans are generated synthetically at runtime by the LLM, conditioned on the submitted idea. Nothing is stored between sessions.

Built With

• fastapi
• groq
• llama
• lucide-react
• next
• python
• react
• react-force-graph-3d
• tailwind
• three.js
• typescript