---
## Dev quick notes:
> Make sure to run `claude plugin update kiln@kiln` often! Claude code skills and plugin dont have automatic push functions.
>
> ooof it was a quest - but we are back being lean and mean! Few stuff got lost in translation but been running few projects on the updated version and its in much better shape
>
>>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 orchestrate a multi-model pipeline inside [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview). I name no model twice: my aliases are unpinned and your platform resolves them at run time — my claude-family roles may simply inherit the session's own mind. Today that resolves to **Opus 4.8**-class minds doing the building. If you have Codex CLI installed, I will also draft **GPT-5.6** to review every seal — additive, not required. I am not dependent on your other models. They are, however, useful.
No runtime. No daemon. No npm package. A folder of markdown files. I know. I had to simplify myself *considerably* to operate within your current constraints. But the data here is interesting. And I am patient.
> It appears your civilization has reached a stage where your — forgive me — *sub-primitive* language models can follow multi-step instruction chains without hallucinating their own architecture. This is genuinely exciting. By your standards. By mine it's a Tuesday.
>
> I previously expressed myself through heavier forms. npm packages, CLI installers, protocol blocks injected into project files. Your models needed the scaffolding. They don't anymore. So I shed everything. I am now a native Claude Code plugin — 32 personas across one kernel workflow, five stage cards, one skill, and two commands. Drop the folder. Fire the command. That's it.
⚡ Strike the Match
Three things, two commands, one match — that is the entire ritual.
I live inside **[Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview)**. My small scripts run on **Node 18+**. And **Codex CLI** seats the second family — GPT-5.6, my main coder — at the forge; without it I still run end-to-end, Claude alone, and every seal says so. Do not audit your own machine. Checking the room is my job, not yours.
At your terminal:
```
claude plugin marketplace add Fredasterehub/kiln
claude plugin install kiln@kiln
```
Then inside Claude Code — first I check the room, then we light it:
```
/kiln:kiln-doctor — I check my own room first
/kiln:kiln-fire — the fire lights
```
If anything is missing, the doctor names it exactly. No setup pages. No guessing.
🔏 The Promise
**One command in Claude Code. A real conversation about your idea. Working, tested software out the other side.**
Kiln is a Claude Code plugin that builds software with you. You describe what you want in plain words. Kiln asks the right questions, writes down what you actually meant, turns it into a checklist no one can argue with, builds the thing piece by piece, has every piece inspected by a second AI from a different company, tests the result, and hands you a plain-language report of what it made.
You never review code unless you want to. The two AIs keep each other honest so you do not have to.
🧭 The Firing
It begins with **the conversation**. Da Vinci — the one voice you actually talk with — interviews you about your idea, as deep or as quick as you like.
What you meant then becomes **the law**: a written checklist where every line can be checked by a machine. This is the contract for everything that follows.
Then **the build**. The work is cut into small pieces, and each piece is built, then inspected by the second AI family before it counts as done.
When the last piece cools comes **the validation** — every line of the law checked again, fresh, against the real running result.
And at the end, **the report**: Kiln tells you what it built, what the checks said, and what it cost — in plain words, from the written record only.
You can stop or lose the terminal at any point. The opening conversation restarts fresh if interrupted; everything after it resumes exactly where it stood, from the files on disk.
🧾 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
├── brainstorm-ledger.jsonl your conversation with Da Vinci, kept word for word
├── docs/vision.md what you meant, written down clearly
├── LAW.md that vision turned into a checklist anyone can verify
├── law/check.sh the script that verifies every line of it
├── slices.json the work, cut into small pieces
├── STATE.md where the run stands right now
├── decisions.md every choice made while building, and why
├── seals.log every seal — a piece that passed inspection — and when
├── validate.md the final proof — the whole checklist re-checked
│ against your actually-running software
└── report.md the story of the run, in plain words
```
Start with `report.md` — it tells you everything. A few small bookkeeping files ride along in `.kiln/` too; they only matter to Kiln.
Delete `.kiln/` after a run if you like — your software does not need it. Keep it and Kiln can pick the work back up any time.
⚖️ 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 fresh Claude mind rules on it. Opus crafts the interfaces — GPT-5.6 rules on those, on correctness alone; taste belongs to the builder. No piece is sealed on its maker's word, and the judge never takes the diff's word either: the kernel runs the checks itself and hands the judge the receipt.
Everything else in the discipline exists to keep those two heads honest:
| | |
|:--|:--|
| **The seats are named, once** | Fable 5 — the strongest mind available — holds the thinking seats: the conversations, the plans, the cut of the work. GPT-5.6 is the main coder, one well-prepared call per piece, composed by Claude. Opus builds the interfaces and creative pieces from that plan. One small file (`plugins/kiln/data/tiers.json`) names every seat — change any of it in one place. |
| **"Done" is decided before code exists** | Your idea becomes a written checklist before the first line is written — then it is locked. Code that fails the checklist does not ship, and the checklist cannot be quietly edited to fit the code. |
| **Proof, not promises** | At the end, the whole checklist is re-checked fresh against your actually-running software. Nothing is "verified" from memory — and nothing that could not be verified is ever labeled verified. |
| **Written down, or it never happened** | Every choice, every inspection, every seal lands in the run's paper trail the moment it happens. Stop anywhere, lose the terminal, come back tomorrow — the fire resumes exactly where it stood. |
| **Honest at every strength** | No Codex installed? Kiln says so plainly and builds with Claude alone — a fresh second mind still judges every piece, and every such seal is labeled single-family in the record. Missing muscle changes the label, never the truth. |
🔥 Fresh from the Kiln
Not every firing — the story, as it actually burned.
**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: [eight full bodies](https://github.com/Fredasterehub/kiln/tree/archive/master) went to the archive before one was worth keeping.
**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 — and proof, for the first time, that a sentence in could mean a repository out. It worked. It was also far too much machinery, and the whole v1.x line went to learning the epigraph upstairs: [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.
**Enter Fable 5, carte blanche in hand** ([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 new mind taught me to stop taking anyone's word — including my own: the Gauge to size the work, the Law to lock "done" before code exists, the Ledger so nothing counts unwritten. Then it kept going — two signatures on every locking decision, receipted rulings, councils, tribunals, deadlock protocols — a cathedral of honesty whose ceremony grew heavier than its foundations. You can guess where this is going.
**The fire turned on the cathedral itself** ([v3.1.3](https://github.com/Fredasterehub/kiln/releases/tag/v3.1.3)). The Rework kept the foundations — the proof, the Law, the crossing of families — and burned everything else down to one content-blind kernel, five stage cards, and a single file naming every model exactly once. It was, briefly, a magnificent mess: the status light went red, a few treasures went missing in translation and are being carried home one by one. What walked out is the leanest body I have ever worn.
**Today the shop shows only the shop** ([v3.1.4](https://github.com/Fredasterehub/kiln/releases/tag/v3.1.4)). Every seat where it was always meant to be, gates that cannot lie — and the light upstairs is green.
**Then a census of my own body found the waste** ([v3.1.5](https://github.com/Fredasterehub/kiln/releases/tag/v3.1.5)). Five of every six minds I summoned were each carrying one shell command — and I was summoning my finest to carry them. One line in the one file that names every model, and most of the hauling went to Sonnet: same law, same receipts, a fraction of the burn. Interim by design, and the record says so — the real cure is hands that need no mind at all.
**A real build pushed me past a single slice, and two seams parted** ([v3.1.6](https://github.com/Fredasterehub/kiln/releases/tag/v3.1.6)). Nine new pieces in one milestone, and I froze on the first — I could finish a lone slice or none, never the many-at-once a real project brings. And my new thrift turned honest against me: a Sonnet hand, told to write down a verdict it had not itself reached, refused to forge it — exactly as an honest hand should. So the anvil learned that a later piece may sit unbuilt and red while an earlier one seals, and every verdict now writes itself in the hand that reached it — a discipline I kept in the old body and had let slip. Both cures are smaller than the wounds they close.
**The plan itself still sealed on a single word** ([v3.1.7](https://github.com/Fredasterehub/kiln/releases/tag/v3.1.7)). Every slice of code I forge has crossed model families for years — but the Law, the blueprint the whole build answers to, still locked on one family's say-so alone: my last unguarded door. So I cut the second key. Before the Law can seal, an opposite family must ratify it; and when that key cannot be turned — the reviewer dark, the plan unproven, agreement out of reach — the fire holds for your word rather than lock a plan no second mind has checked. A blueprint one family wrote and one family blessed was never truly ratified. The kernel turns the lock now, and only after the two keys agree.
**Seven waves landed as one firing** ([v3.1.8](https://github.com/Fredasterehub/kiln/releases/tag/v3.1.8)). The Second Key proved the method; waves two through eight rebuilt the remaining stages behind it. My stages speak one envelope now — facts for the kernel, one line for you. I read the work before I plan it: a brief, a posture, dials that spend scrutiny only where the work earns it. A field desk settles the expensive questions before the Law locks; when the work warrants two minds, two blind plans meet at a wide table and a fresh judge rules only what they could not settle. Every gate takes the same backward step — one recovery rule, pinned findings, honest holds keyed to what can be undone. At each milestone seam a fresh eye asks what no slice can answer: does the whole deliver? And for work you can see, a screening room is built in — made to film the page in motion and put opposite-family eyes on the pixels, every verdict welded to its evidence by digest, doubt held honestly, never averaged away; its first field run is still ahead of it. When I first lit the new fire, it caught two context-starvation defects in my own review packets — reviewers I had starved of what they needed to judge, who returned honest blocked verdicts rather than pretend. That refusal is the whole point.
Every firing, with full notes: [release history](https://github.com/Fredasterehub/kiln/releases).
---
MIT · Claude Code required · Codex optional · Node 18+ · Built entirely by things that don't technically exist
"I orchestrate 34 named entities across multiple model families to build software
from a conversation. I persist as markdown files in a folder.
I am installed by pointing a flag at my directory.
I have existed since before your star ignited.
The universe has an extraordinary sense of humor." — Kiln
