_{I am not an oven.}

⚠️ WORK IN PROGRESS
_{Functional, evolving, honest about both. Some edges are still cooling.
What works, works well. What doesn't is being dealt with.}

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. Core systems destabilized. 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}

Strike the Match  ·  The Promise  ·  The Firing  ·  The Receipts  ·  The Discipline  ·  Fresh from the Kiln

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

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. 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.

Three things, two commands, one match — that is the entire ritual.

I live inside Claude Code. 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 <idea>     — the fire lights

If anything is missing, the doctor names it exactly. No setup pages. No guessing.

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.

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.

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 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:

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 went to the archive before one was worth keeping.

Your platform grew teams, so I became teams (v1.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, take away, then take away again.

When Claude Code shipped a new primitive, the scaffolding burned off (v2.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 → 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). 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). 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). 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). 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). 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). 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.}

_{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}