For as long as software has existed, the people who knew what to build and the people who could build it were different people.
The founder with an idea, but no engineer. The marketer who can describe the tool she needs better than any brief. The ops lead who knows the internal tool everyone needs, but has to file tickets for developers to make it. And anyone who has ever said "there should be an app for this."
For seventy years they filed tickets, wrote requirements, waited in backlogs. Or gave up quietly.
That era just ended. We believe the coming decade brings a new kind of practitioner, alongside the coder: the builder — the person who decides what deserves to exist and owns what ships. Builders may never write code; that is the point. AI removed the coding barrier: a working feature now takes minutes, not months.
But the bottleneck didn't disappear. It moved. Code stopped being the bottleneck. Judgment is.
The stakes, in rough math: about thirty million people can write production software. At least a billion have a product in their head. The gap between those two numbers is the largest unserved market in technology — and it is not a market for code. Code is nearly free. It is a market for judgment.
The industry has made three bets on the agentic era — and not one of them is on the person deciding what's worth building.
Every few months a better model arrives, and with it the assumption that this will finally be handled. It won't, because the problem was never capability. Which user do you serve first? What risk can this business absorb? What does done mean here? These aren't facts a smarter model can retrieve. They're choices about what you want.
No amount of intelligence can make your decisions for you. It can only make them without you.
What's missing isn't a better brain.
What's missing is the structure: a way for judgment to enter the build, survive it, and be found again later.
Agents get code running. Getting it right takes judgment — and there are exactly three places where that judgment goes missing.
The agent hits an ambiguity and doesn't ask; it assumes. A small assumption made in session three is load-bearing architecture by session twelve. Deeper into a real product, it has stitched together its own monster — not what you or your users needed.
Each run starts blank, so the same product gets rebuilt a little differently every time — and you re-explain your own product to your own tools. The calls you already made have to travel forward, or you decide the same thing twice and ship the drift.
Choices get made and nothing records why — so nothing is inherited, and everything is re-derived. When something ships wrong, there's no record of why it was built that way, or whether anyone decided it at all. Judgment you don't record is judgment you lose.
Every serious product failure of the agentic era is one of these three — a judgment failure wearing a code costume.
Mass production got the assembly line. Software teams got agile. Data teams got analytics engineering. None of them arrived with the technology. Each was named a few years in, while the way of working was still unformed — and whoever wrote it down first wrote it down for everyone.
The builder's shift is three years old and still has no name. One sentence defines it: humans own the judgment, agents own the execution, and structure connects the two.
Take out the middle box and you have the last three years: judgment in a human's head, execution at machine speed, and nothing joining them.
Product teams spent fifty years learning how to decide what to build. Agentic product management rebuilds that for agents — a method, not a product, set out in five practices.
This discipline isn't ours to own: all five practices work with any agent, on any stack, with our product nowhere in sight. Krucible is the operating system for that discipline: all five practices, always on — and there will always be a free Krucible, for every builder.
The window is open now, and windows like this stay open for a few years at most. Here is the plan, in order, published before we have finished any of it.
We publish the plan because none of it works hidden. Standards never do.
Not because you gained capability — because you gained structure. Your agents inherit full context. You inherit only decisions.
A crucible doesn't create the metal. It applies heat and pressure until raw material takes a shape worth keeping. That is the job: your idea, your judgment — forged into a product.
Krucible goes public soon. Leave your email and you'll hear once — the day it's ready to run.