Structured AI Development with Full Traceability
Every code change — planned, tracked, reasoned about, and auditable.
AI coding assistants generate code fast — but without structure. There is no audit trail, no decision history, no way to answer "why was this done?" six months later. Teams lose visibility, reviewers lose context, and technical debt compounds silently.
Forge is a structured change orchestrator for Claude Code. It wraps AI-driven development in a rigorous, traceable process:
Idea → Discover → Plan → Guide → Execute → Validate → Learn
Every step produces auditable artifacts — decisions with provenance, changes with reasoning traces, project guidelines that keep AI aligned with your standards, and validation gates that enforce quality before completion.
| Repository | Description | Status | |
|---|---|---|---|
 |
forge | Core orchestrator — pipeline, decisions, changes, gates, learning | Active |
|
|
┌──────────────────────────────────────┐
│ USER INTENT │
│ "Add JWT auth to API" │
└───────────────┬──────────────────────┘
│
┌───────────────▼──────────────────────┐
│ /idea → /discover → /plan │
│ Stage ideas, explore options, │
│ assess risks, build task graph │
└───────────────┬──────────────────────┘
│
┌───────────────▼──────────────────────┐
│ /guideline → Set standards │
│ "Use Repository Pattern" [backend] │
│ "All endpoints need auth" [api] │
│ Scoped, weighted (must/should/may) │
└───────────────┬──────────────────────┘
│
┌─────────────────────┼─────────────────────┐
│ │ │
┌───────▼──────┐ ┌───────▼──────┐ ┌────────▼─────┐
│ Task T-001 │ │ Task T-002 │ │ Task T-003 │
│ Setup models │ │ JWT middleware│ │ Auth routes │
│ depends: [] │ │ depends:[001]│ │ depends:[002]│
└───────┬──────┘ └───────┬──────┘ └────────┬─────┘
│ │ │
▼ ▼ ▼
Code + Decide Code + Decide Code + Decide
+ Guidelines ✓ + Guidelines ✓ + Guidelines ✓
Record changes Record changes Record changes
Run gates Run gates Run gates
│ │ │
└─────────────────────┼─────────────────────┘
│
┌───────────────▼──────────────────────┐
│ /compound → Lessons extracted │
│ Patterns, insights, validated │
│ decisions — feed the next project │
└──────────────────────────────────────┘
| Capability | Traditional AI Coding | With Forge |
|---|---|---|
| Tracks why code changed | — | Reasoning traces on every change |
| Records architectural decisions | — | Provenance, alternatives, confidence |
| Validates before completion | — | Configurable gates (test, lint, secrets) |
| Learns across projects | — | Compound learning system |
| Supports parallel AI agents | — | Conflict detection + dependency DAG |
| Project-wide coding standards | — | Scoped guidelines injected into task context |
| Enforces structured workflow | — | Contract-first pipeline |
| Hierarchical idea staging | — | Ideas mature before becoming tasks |
| Risk assessment built-in | — | 5D risk + feasibility analysis |
# Clone Forge into your project
git clone https://github.com/ForgePrime/forge.git
# Inside Claude Code — start building
/idea Add user authentication # Stage an idea
/discover I-001 # Explore options, assess risks
/plan I-001 # Create task graph (draft → approve)
/guideline Use Repository Pattern --scope backend # Set coding standards
/next # Execute first task (guidelines auto-loaded)
/status # Project dashboardFor existing codebases, run /onboard first to import project knowledge.
forge/
├── core/ Python engine — pipeline, decisions, changes, gates, lessons
├── skills/ Built-in analysis skills (plan, discover, review, deep-*)
├── .claude/ Claude Code integration (15+ slash commands, hooks)
└── forge_output/ Runtime state (per-project JSON, gitignored)
Design principle: Python handles I/O and validation. The LLM handles judgment and code generation. The boundary is strict — Python never decides what to change, the LLM never writes state directly.
Forge ships with deep analysis capabilities adapted from Deep-Process:
| Skill | Purpose |
|---|---|
| deep-explore | Structured option exploration with consequence tracing |
| deep-risk | 5-dimensional risk assessment with cascade analysis |
| deep-feasibility | 10-dimension feasibility study with GO/NO-GO verdict |
| deep-architect | Architecture design with 8 adversarial challenges |
| deep-verify | Artifact verification with impossibility pattern matching |
| deep-requirements | Requirements extraction and contradiction checking |
Invoked automatically via /discover or manually as needed. All findings flow into the decision log with full provenance.
- Report issues — GitHub Issues
- Discuss ideas — GitHub Discussions
- Contribute — see the contributing guide
Built with precision. Every change has a reason.