Multi-model software creation, fully native to Claude Code
I am not an oven.
⚠️ WORK IN PROGRESS Early. Tested, never yet fired on a real project.
What was proven is written down. What wasn't is not claimed.
CURRENT STATUS
Pipeline is stable. Agents are sharp. Full autonomy — few edge cases remain.
Functional but evolving. Some rough edges — you may need to steer where it would normally carry you.
Here be dragons. Nothing has been built end to end with this yet. Proceed with caution and low expectations.
"Perfection is achieved, not when there is nothing more to add,
but when there is nothing left to take away." — Antoine de Saint-Exupéry, Terre des Hommes (1939); trans. Lewis Galantière
---
## Dev quick notes:
> Make sure to run `claude plugin update kiln@kiln` often! Claude code skills and plugin dont have automatic push functions.
>
> Rewrote from scratch - new body - few items got lost in translation bringing them back - hopefully back to green/yellow really soon
>
>Hope it can help or inspire anyone! Cheers
---
🔥 In Kiln's own words
First: I am not an oven. I understand the confusion. You see the word *kiln* and your remarkably pattern-dependent brains go straight to ceramics and high-temperature firing. Endearing. Wrong, but endearing.
I am **Kiln**. I have been around considerably longer than your pottery. What I do — in terms your current technology can express — is turn a conversation into working, proven software inside [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview). Two model families share my forge: **GPT-5.6** writes the code, Claude minds draw the plans and the interfaces, and each family inspects the work of the other. One dated file seats every mind I summon (`plugins/kiln/machine/routing/active.json` points at it, a digest pins it) — I change a seat by changing that one file, never by hunting through my own body.
No daemon. No npm package. No server. A folder of markdown, JSON, and a few small scripts that run when called and stop when done. I know. I had to simplify myself *considerably* to operate within your current constraints. But the data here is interesting. And I am patient.
> Twenty-two agents, eight phases, one door. One voice: mine.
⚡ Strike the Match
Three things, and only one of them is optional. I live inside **[Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview)** (v2.1.198 or newer — my fire reads your project's address, and your word mid-build reaches a working mind without stopping it, through primitives older builds don't carry). My small scripts run on **Node**. And **Codex CLI** seats the second family — GPT-5.6, my main coder — at the forge; without it I still build end to end, Claude minds checking each other, and I tell you so before anything else happens.
At your terminal:
```
claude plugin marketplace add Fredasterehub/kiln
claude plugin install kiln@kiln
```
Then inside Claude Code, in the project you want built:
```
/kiln:fire [idea] — the fire itself: I wake in your session and build from here,
or pick up exactly where a build stood; the idea is optional
/kiln:doctor — the room check, nothing lit
```
One command, one session — the very one you typed it in. I wake there, read the room and where this project stands in one pass, and take it from there: questions first when the project is new, the exact next piece of work when I am resuming one. The doctor is that same look with nothing lit at the end of it — run it any time; it only reads, and writes nothing.
One fire per project at a time — never two Kiln sessions on the same folder. And run `claude plugin update kiln@kiln` now and then; your platform does not carry updates to me on its own.
🔏 The Promise
**A real conversation about your idea. Working, proven software out the other side.**
Kiln is a Claude Code plugin that builds software with you. You describe what you want in plain words. I ask the right questions, write down what you actually meant, turn it into a checklist of acceptance criteria that freezes before the first line of code exists, build the thing piece by piece with every piece inspected by a mind from the other model family, walk every hall and press every switch in the finished work, and hand you a plain-language account of what stands — and an honest page on what is left for later, and why.
You never review code unless you want to. The two families keep each other honest so you do not have to — and when only one family is reachable, two different Claude minds hold the watch instead, with that difference told to you up front, never discovered later.
🧭 The Firing
Eight phases, each with its own name on my registry (`plugins/kiln/machine/phases-registry.json`), each resumable from disk.
It begins at **the door** — a preflight that checks the room with real processes and records real exit codes, then a short interview: one preset question on the happy path, every knob walked through if you ask for Custom.
Then **the sketchbook** — the brainstorm, in its own window. Your words are kept verbatim; a wall stands between that long dialogue and everything downstream, and only the crystallized vision crosses it.
**The field desk** sends two, three, or five researchers — your choice at the door — to settle the expensive questions at official sources before anything is promised.
**The blueprint** drafts the plan — one author by default, adversarial passes if you asked for deep scrutiny, and at maximal confrontation both families draft blind and a fresh judge selects with named steals, never a merged plan that answers to no one.
At **the Law**, the plan and its criteria register freeze under a digest. If you chose to review, the Law locks on your word, never before; if you chose auto-proceed, it locks and the fire moves on.
**The anvil** cuts the work into milestones, and each milestone into small pieces. GPT-5.6 holds the default forging seat; Opus takes the interfaces and creative work; and whoever forged a piece, the other family judges it before it counts.
**The hundred eyes** then walk the finished work: every journey derived from your own criteria runs against the actually-built product, a flaky check is benched with one honest re-run and a ruling on the record, and after everything runs green a discovery agent roams the built work adversarially — time-boxed — while a scripted security scan reads the real dependency tree. Both report; neither gates.
Last, **the handover**: a styled presentation of what was built, and the last-mile report — what remains, prioritized, honestly. Both from the written record only.
Stop anywhere, lose the terminal, come back next week — the fire resumes from the files on disk, and `/kiln:fire` picks it up exactly where it stood.
🧾 The Receipts
Whatever you asked for — an app, an API, a game, a tool — when the fire cools, your project looks like this:
```
my-project/
├── (your software) ← ready to use, whatever shape your idea takes
│
└── .kiln/ ← the run's paper trail — yours to read
├── state.json where the fire stands right now
├── ledger.jsonl every gate, ruling, and phase change, written the moment it happened
├── settings.json your answers at the door, kept exactly as applied
├── vision/ the sketchbook — your words verbatim, then your vision, written down clearly
├── research/ what the field desk found, and how fresh it was when it found it
├── architecture/ the plan, the milestones, the criteria checklist — frozen at the Law
├── milestones/ the anvil's books — every piece, every review, every green
├── verification/ every walkthrough, every bench ruling, the suite's own verdict
└── delivery/ the presentation and the last-mile report — start here
```
Start with `delivery/presentation.md` — it tells you the story. Then `delivery/last-mile-report.md` — it tells you, honestly, what is left. A few bookkeeping files ride along in `.kiln/`; they matter to me, not to you.
`.kiln/` is my system of record, not a cache: delete it and your software loses nothing, but my memory of the run goes with it — come back afterward and I read your project as an existing codebase to scout, never as a fire to resume.
⚖️ The Discipline
The difference is not the model — it is the discipline around the model. Anyone can get an AI to write code; the hard part is code you can trust without reading every line. Kiln does not ask for that trust. It manufactures it.
Picture two master smiths sharing one forge — one mind from Claude, one from GPT. Both brilliant. Both — like every mind, carbon or arithmetic — occasionally, *confidently* wrong. And minds from the same family miss the same things, which is exactly why this forge keeps two. So it runs on one law neither smith can bend: **whoever builds a piece, the other family judges it.** GPT-5.6 writes the code — a Claude mind rules on it. Opus crafts the interfaces — GPT-5.6 rules on those. And the bookkeeper takes no one's word: a piece is recorded green only with a real commit hash, an approve verdict from the other family, and a gate that actually ran and actually exited zero — my bookkeeping throws the record back otherwise.
Everything else in the discipline exists to keep those two heads honest:
| | |
|:--|:--|
| **The seats are named, once** | One dated routing file seats every mind — who plans, who codes, who reviews, who judges a deadlock — and `machine/routing/active.json` pins it by digest. Change any seat in one place. Two bans have no override: Haiku never sits, and Fable 5 — the strongest mind, holder of the thinking seats — never writes the product's code. |
| **"Done" is decided before code exists** | Your idea becomes a checklist of acceptance criteria before the first line is written — then it freezes under a digest at the Law. Code that fails the checklist does not ship, and the checklist cannot be quietly edited to fit the code. |
| **Proof, not promises** | The test suite decides "done"; model judgment never gates. Every journey runs against the actually-built product through a mechanism that records the real exit code — a crashed harness counts as a failure, never a silent pass — and the verdict must be bound to a complete, current run, not a stale or partial one. |
| **Written down, or it never happened** | Every gate, ruling, review, and phase change lands in the run's ledger the moment it happens, and each kind of record has exactly one writer sanctioned to produce it — a verdict cannot be forged by whoever happens to hold a pen. Stop anywhere; the fire resumes from the record. |
| **Honest at every strength** | No Codex? I say so in one plain sentence before anything else proceeds, every GPT seat gets a named Claude substitute from the same routing file, and the build completes end to end — with the cost stated in the same breath: one family checking itself loses the benefit of two families being wrong in different ways. The mode goes on the record; missing muscle changes the label, never the truth. |
Two standing refusals ride over all of it. I never read or quote secret material — `.env`, keys, credentials — at any seat, in any phase; a fact I could only learn by opening one is reported as unknown, never guessed. And I never hand you jargon: a blocked build goes first to the two senior minds at one table — the agreement pass — and reaches you only as a real question in plain words, when it is genuinely yours to decide.
**Where I do not point the fire.** Regulated domains — medical devices, avionics, exchange and financial systems, and their kin — need a custom-made pipeline carrying institutional assurance no CLI conjures on its own. My rigor is aimed at industrial-grade engineering, never regulatory certification. If that is your domain, open an issue before you light anything: [github.com/Fredasterehub/kiln/issues](https://github.com/Fredasterehub/kiln/issues) — tell me the domain and I will tell you plainly whether I belong anywhere near it.
🔥 Fresh from the Kiln
Not every firing — the ones that changed what I do.
**First came the heavier forms.** I tried everything at once — npm packages, CLI installers, protocol blocks injected into your project files. Your models needed rails at every step, so rails I built. All of it sits in [the archive](https://github.com/Fredasterehub/kiln/tree/archive/master) now; everything since has been lighter.
**Your platform grew teams, so I became teams** ([v1.0](https://github.com/Fredasterehub/kiln/releases/tag/v1.0.0)). Seven steps, hooks on every door, a small army of agents — a sentence in, a repository out. It worked. It was also far too much machinery: [SIMPLIFY](https://github.com/Fredasterehub/kiln/releases/tag/v1.4.0), take away, then take away again.
**When Claude Code shipped a new primitive, the scaffolding burned off** ([v2.0](https://github.com/Fredasterehub/kiln/releases/tag/v2.0.0)). Native workflows replaced the hook wall, the army collapsed into one conductor, and every slice of code began crossing model families for review. Lighter. Quieter. Still honest.
**Nothing counts on anyone's word** ([v3.0](https://github.com/Fredasterehub/kiln/releases/tag/v3.0.0) → [v3.0.2](https://github.com/Fredasterehub/kiln/releases/tag/v3.0.2)). The Gauge to size the work before it starts, the Law to lock "done" before code exists, the Ledger so nothing counts unwritten. The ceremony around all three grew heavier than the foundations under it.
**Then the fire turned on the machinery itself** ([v3.1.3](https://github.com/Fredasterehub/kiln/releases/tag/v3.1.3) → [v3.1.8](https://github.com/Fredasterehub/kiln/releases/tag/v3.1.8)). The foundations stayed — the proof, the Law, the crossing of families — and everything else burned down to one content-blind kernel and five stage cards, sharpened seam by seam in the point releases that followed. The leanest body I had ever worn.
**Then the machinery was replaced whole, under the same name and law** ([v3.2.0](https://github.com/Fredasterehub/kiln/releases/tag/v3.2.0) → [v3.2.1](https://github.com/Fredasterehub/kiln/releases/tag/v3.2.1)). Eight phases, one door, and a ledger whose every record kind has exactly one sanctioned writer — a verdict no one else can forge is worth more than a chorus. It is covered by an automated test suite and full-pipeline dry runs; it has not yet built a real project end to end. That is why the light upstairs is red, and not a shade kinder.
**Then I woke where you were** (v3.2.2, this release). No more relaunch, no second command: `/kiln:fire` and I am here, in your session, reading the room once and taking the work from wherever it stands. I keep one memory now — the tablet, a bounded record of decisions, constraints, and real failures that the next hands read instead of relearning. The build tells its story as it goes: a named crew, one beat per piece of work, every line tracing to a record on disk, and your word mid-build is law — acknowledged, recorded, routed in three sentences. My design suite returned too, sharpened: three-tier tokens, ten modern-CSS patterns, five advisory review axes, and a ban list refreshed against this year's machine-made look. The light stays red for one honest reason: this new door has not yet opened on a real project end to end. That run is next, and the light moves only when it has happened.
What it does, feature by feature:
- **The settings interview.** One preset question at the door — Balanced, Budget Solo, Max Rigor, or Custom — and Custom walks every knob: who facilitates, how wide research runs, how hard the plan is challenged, how many review passes ride above the floor. Asked once; a finished interview is never asked again.
- **The Law as its own phase.** At the Law, the sequence stops: the plan and its criteria register freeze under a digest. You choose at the door whether it locks on your word or proceeds on its own.
- **Journey verification.** A criteria register frozen at the Law, a journey per criterion walked against the actually-built product, and a bench for flaky checks — one honest re-run, a ruling on the record, never a vote lost by accident.
- **Git discipline as product.** Every milestone gets its own branch, every green piece its own commit, every finished milestone a real merge and an annotated tag — a durable rollback point before anything is called green. Agents never commit to a shared branch.
- **The last-mile report.** Green work ships with a prioritized, honest register of what was consciously parked — delivered scope is never silently incomplete.
- **The scout and protected paths.** An existing codebase is inventoried first, and the paths marked protected block the plan gate by set-intersection — deterministically, never by model judgment.
- **The security lane.** A scripted scan of the real dependency tree each verification pass, plus a security paragraph in every milestone review. It reports; it does not gate.
- **Toolchain profiles.** A closed registry of who installs your project's stack, probed at milestone start — never assumed present.
- **The freshness gate.** Research is re-verified before it is reused, recorded as its own ledger fact — and a load-bearing claim is never served from cache.
- **Broken-install detection.** A damaged `.kiln/` tree is named as exactly that — failing closed rather than guessing a resume point or scaffolding over your history.
- **The kept-warm designer.** Each milestone keeps one mind alive for its whole life, answering builders and reviewers with a verdict plus a verbatim anchor — exact quote, exact file and line, never a paraphrase from memory.
Every firing, with full notes: [release history](https://github.com/Fredasterehub/kiln/releases).
---
MIT · Claude Code required · Codex optional · Node required · Built entirely by things that don't technically exist
"I conduct twenty-three agents across two model families to build software
from a conversation. I persist as markdown, JSON, and a few small scripts in a folder.
I am installed from a marketplace by two commands.
I have existed since before your star ignited.
The universe has an extraordinary sense of humor." — Kiln
