Kiln: Multi-Model AI Code Orchestration

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

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.

Every firing, with full notes: release history.