Forgekeel

Disciplined Claude Code. Memory, judgment, execution — so you ship production software, not vibe-coded prototypes that break in prod.

Forgekeel is a methodology for orchestrating Claude Code on real projects. It replaces improvisation with a small set of opinionated parts: specialized subagents, slash commands, a per-project constitution, a learnings loop, and — at the heart of it — KERNEL, a scored quality gate every change has to pass before code is written.

Built for builders shipping production software on Next.js + Supabase + TypeScript.

The problem

Claude Code in raw form is a brilliant improviser. That's the problem.

• Tickets get written without scope or risk → it ships something, but not what you asked.
• It writes code before there's a plan → you debug the plan in production.
• Security and UI review live in the same head as the implementation → nothing catches the obvious.
• Each session forgets what the last one learned → you re-discover the same bugs.

Forgekeel constrains that. Every change passes a gate. Architecture is decided read-only by one agent before another touches the keyboard. Security and UI get their own reviewers. Each closed ticket leaves a written lesson the next ticket reads.

The three layers

| Layer | What it does | In Forgekeel | |---|---|---| | Memory | What the AI knows across sessions | The constitution + the learnings file | | Judgment | How the AI decides what's worth doing | The KERNEL score (gates every ticket) | | Execution | How the AI builds | Specialized subagents + slash commands |

This repo is the open-core of Forgekeel: the full execution layer, the KERNEL gate, the constitution template, and the patterns of the memory layer. A deeper judgment layer (the how to think with it) ships separately.

KERNEL — the quality gate

Every ticket scores against six orthogonal dimensions (100 points total). The score decides what happens:

• < 60 → reject. Send back with concrete flags.
• 60–79 → conditional. architect (read-only) drafts a plan before any code is written.
• ≥ 80 → execute. builder proceeds.

Clarity     20   Is the objective unambiguous in one sentence?
Scope       20   Are inclusions and exclusions explicit?
Context     15   Enough context to execute without asking?
Risk        15   Risks identified and mitigated? (auth, DB, migrations, PII)
Validation  15   Acceptance criteria verifiable and reproducible?
Priority    15   Does this advance an active goal?

A ticket that scores 95 and breaks production is worse than one that scored 65, was flagged, and got a plan first.

Full rubric in .claude/methodology/KERNEL.md.

KERNEL in action

A ticket comes in: "Add password reset email."

Clarity      15 / 20   "Reset" undefined — link only, or full flow + template?
Scope        10 / 20   No mention of expiry, rate limits, or email provider
Context       8 / 15   Doesn't say which auth provider or where templates live
Risk          5 / 15   Auth flow + email = high risk, not addressed
Validation    8 / 15   "Make it work" isn't testable
Priority     12 / 15   Active KPI
                       ─────
                       58 / 100   → REJECT — return for clarity, scope, risk, validation

Forgekeel refuses to write code for this until the ticket is rewritten. Compare with the version a senior would actually send:

Clarity      19 / 20   Add `/reset-password` flow: email link with 30-min expiry token
Scope        18 / 20   This ticket: link email only. Excluded: SMS, recovery codes
Context      14 / 15   Supabase Auth `resetPasswordForEmail`. Template in /emails/
Risk         13 / 15   Rate-limit 3/h per email. No token leak in logs. RLS audit
Validation   13 / 15   Cypress: request reset, click link, set new password, login
Priority     13 / 15   Unblocks login retention KPI
                       ─────
                       90 / 100   → EXECUTE

Same problem, two tickets, two outcomes. KERNEL is the difference between debugging in your editor and debugging in prod.

The subagents

Forgekeel ships seven specialized agents. Read-only agents (architect, security-auditor, ui-reviewer) never touch files — their job is to think, not type.

| Agent | Model | Tools | Role | |---|---|---|---| | architect | Opus | read-only | Designs systems, plans migrations, weighs trade-offs | | builder | Sonnet | write | Implements features and fixes | | tester | Sonnet | write (tests only) | Writes and runs tests, builds, type checks | | security-auditor | Opus | read-only | Audits RLS, auth, secrets, Server Actions | | designer | Sonnet | write | Iterates UI against declared design tokens | | ui-reviewer | Opus | read-only | Visual review against tokens; verdict only | | researcher | Haiku | read-only | Looks up APIs and docs |

The commands

Ten slash commands cover the loop end-to-end:

| Command | What it does | |---|---| | /feature | Execute a feature ticket through KERNEL gate + delegation chain | | /debug | Diagnose and fix a bug with hypothesis-ranked plan | | /migrate | Plan and run a DB migration (security-auditor required) | | /audit-rls | Audit RLS policies on every table | | /security-audit | Full security pass: secrets, env, auth, injection vectors | | /scan-repo | Read-only inventory of the codebase | | /design-iterate | Producer/critic loop for UI (designer ↔ ui-reviewer, max 3 cycles) | | /review | Code review pass | | /status | Snapshot: branch, dirty files, pending tickets | | /close-ticket | Verify acceptance, validate, log learnings, commit |

Quickstart

# 1. Clone Forgekeel
git clone https://github.com/forgekeel/forgekeel ~/forgekeel

# 2. Drop its .claude into your project (creates YOUR_PROJECT/.claude)
cp -r ~/forgekeel/.claude YOUR_PROJECT/

# 3. Fill in the constitution for this project
cd YOUR_PROJECT
cp .claude/constitution/template.md .claude/constitution/project.md
# → edit project.md with your stack, design tokens, and restrictions

That's it. Open Claude Code in your project and the agents + commands are available. Start with /status or /feature.

Full walkthrough in docs/quickstart.md.

What's in the box

forgekeel/
├── .claude/             # drop this into your project
│   ├── agents/          #   7 specialized subagents
│   ├── commands/        #   10 slash commands
│   ├── constitution/    #   per-project template
│   └── methodology/     #   KERNEL rubric
├── docs/
│   └── quickstart.md
├── LICENSE              # MIT
└── README.md

Stack assumptions

Forgekeel is opinionated and stack-locked on purpose. Agents and commands assume:

• Next.js App Router, TypeScript strict
• Supabase (Auth + DB + RLS + Edge Functions) via @supabase/ssr
• Tailwind v4 with @theme
• shadcn/ui
• pnpm, Vitest, Playwright (via MCP)

If your stack is different, you'll need to adapt the agents. There is no plan to make Forgekeel stack-agnostic — opinions are the point.

Status

v0.1.0 — first public release. Used internally to ship real projects since April 2026.

The deeper judgment layer (how to actually think with it, not just run it) ships as a paid companion. Watch this repo for the release.

License

MIT — © 2026 Alex Cano. Use it, fork it, ship with it.