Every time a team upgrades to a bigger, pricier AI model to make its code generation more reliable, it is buying one thing. Not correctness. Not certainty. A slightly better class of guess.
That is the reframe at the center of a piece I wrote that just ran on HackerNoon — AI Is Guessing. We Stopped Paying Extra for Better Guesses. — and it is worth restating here, because it is the idea Gainable is built on. This is the short version. The full argument, with the benchmarks and the architecture, is on HackerNoon.
The trap: paying more for a better guess
A large language model predicts the next token. That is the whole mechanism. It is probabilistic by design, which means every output is a guess — a very good one, often, but a guess. For a chat reply, a wrong guess costs you a re-roll. For a 120-file application wired to live business data, a wrong guess costs you a production incident.
So the industry does the obvious thing: it buys a bigger model. Bigger models guess better, errors drop, everyone moves on. The problem is the shape of that curve. Your cost climbs in a straight line while your reliability gains flatten out. You are treating reliability as an insurance premium you pay per generation, forever, instead of as an architecture problem you solve once.
What you are buying, though nobody words it this way, is a slightly better class of guess.
We took the opposite bet. Do not buy better guesses. Remove the need to guess.
Shrink the target
The model in our pipeline never writes the application. It writes a structured contract — a precise description of the data model, the entities, the relationships, the views. That is a much smaller, much more constrained job than emitting 18,600 lines of correct code, and a smaller job is one a model gets right far more often.
A deterministic compiler — we call it Gaia Synthesis — turns that contract into the actual code. Same contract in, same code out, every time. The compiler does not have a bad day. It does not get creative at 2 a.m. The part that has to be reliable is the part that cannot guess at all, and the part that guesses has been shrunk to something it can handle.
Make a wrong guess free
Then we made wrong guesses cheap enough to stop mattering. Ninety-seven validators check every build before a human ever sees it — data flow, auth, layout, logic. Each validator encodes a lesson from a past failure, so the system gets harder to break over time instead of easier. When a bad output is caught automatically, before it can reach anyone, its cost collapses toward zero.
When a wrong guess costs nothing and is caught before it can do harm, you stop buying insurance.
To put a number on it: a 120-file event-operations app, about 18,600 lines, built from an Excel file in six minutes. Production builds average around $2 in tokens, against the $300-plus you would spend routing the same work through a frontier model and hoping. We also ran the output against the AIUC-1 certification standard — 543 applications analyzed. It surfaced exactly one architectural gap, unauthenticated APIs, which we fixed once, at the platform level, for every app.
Own the model
There is a third payoff that only shows up once the first two are in place. When the job is a narrow, well-specified contract and a verification layer stands behind it, you no longer need the biggest general-purpose model on the market. A smaller, custom model becomes viable — which means you are not renting your core capability from a vendor who can reprice, deprecate, or out-compete you next quarter. I have written before about why, if the LLM is your engine, you don't own your product. Determinism is how you get the engine back.
What this means if you are the one building
If you are an ops lead or a founder pointing a tool at your spreadsheet, none of this is your problem to think about — and that is the point. Because the app is validated before it reaches you, you are not the QA layer. Because a build costs a couple of dollars instead of a couple hundred, iterating is free enough to actually iterate. And because the reliability lives in the architecture rather than in how much you spent on this particular generation, the app you get on a Tuesday is the app you get every time.
The industry's answer to unreliable AI has been a bigger model. Mine is less model, in fewer places, doing a smaller job, checked by something that cannot guess at all.
This is the same argument I made about why I think AI is building software backwards: most of the field starts from the prompt and scales the model. We start from your data and shrink the guess.
Read the full piece
The complete version — the cost curves, the validator design, and the AIUC-1 results in full — is on HackerNoon: AI Is Guessing. We Stopped Paying Extra for Better Guesses.
If you would rather see it work than read about it, drop a spreadsheet into Gainable's Excel-to-app builder and watch the data model it extracts. That is the small, checkable job in action.