The Crucible

In goes the idea. Out comes the product you own.

Old crucibles told you if the gold was real. This one does it for what you built: it asks five plain questions first, then proves the result against six gates before it reaches you. Then it is yours, to own outright or let the forge keep running.

IntelliBotique is the practice. The Crucible is its product. The Smelters are products built on the Crucible, each one shaped for a different kind of maker.

Before a line of code

Five questions, asked first.

Most software gets built before anyone checks whether it should exist. The Crucible works the other way round. A bad answer here costs you an afternoon. The same answer after launch costs you a year.

I

Real problem?

Is somebody actually stuck on this, or does it merely sound useful when you say it out loud?

II

Pays for itself?

What it costs to run, what somebody would plausibly pay, and whether those two numbers survive being put next to each other.

III

Legally clear?

The claims it would make, the data it would touch, the promises it quietly implies. Not legal advice.

IV

Buildable?

Can this be built as described, at this scope, with what exists today.

V

Release-safe?

Whether it could go in front of real people without costing you your reputation.

The signed plan

Nothing gets built until you sign that plan. It is the whole agreement in one page: what this is, who it is for, what it will not try to do, and which risks you decided to accept anyway. Change a signed field later and it comes back for your signature.

The part nobody shows you

Six gates, on your side.

Anyone can show you a demo that looks finished. A Crucible build proves itself first: six gates stand between the fire and your hands, each one there to protect what you are about to own. A red gate pauses delivery and tells you plainly what it found. What happens next is your call, not ours.

Build integrity

It compiles. An unresolved import is a product that will not start on the machine you put it on.

Build checks

Duplicate modules, unsafe cookies, missing security headers, dead code. The dull failures that reach production most often.

Accessibility

WCAG 2.2 AA. Shipping a product that some of your users cannot operate is a decision, so it is treated as one.

Build and run

It gets built and started for real, not inspected and assumed. A product that only compiles is not a product.

Design craft

Whether it looks like something a person made on purpose, rather than the default output of a machine.

Delivery assay

The finished build, measured against the plan you signed. Every check reported as measured, and anything it could not measure disclosed rather than counted as a pass.

And you stay in charge: any gate can be signed past, knowingly. The gates inform your call. They never take it from you.

What you end up holding

The source, the papers, the keys.

Whichever door you take, the thing at the end is real software. Not an embed, not a share link, not a folder that needs a rebuild before it will start.

The source

Every file, in the open. Change a line, add a feature, or hand it to a developer who will.

The papers

A README that explains what got built and why, a DEPLOY file a person can follow, and the assay certificate saying what was measured and what was not.

The keys

It runs where you say: your laptop, a rented server, the cloud account with your name on the invoice.

The Smelters

Two doors already cut.

A Smelter is the Crucible set up for one kind of maker. Two are running now. The forge is invitation-only for now: join the waitlist, and the invitation lands when your place opens. Smelter is the first door cut into this forge, not the last.

Worth knowing before you choose: every build faces the same six gates on the way out, whichever door it came in.

You had the idea

Find out if it holds.

Five plain questions, a plan you sign, and a product that has to pass its gates before it reaches you.

Not legal advice. Not financial advice.