Two cents a build: the economics of proof

I almost didn’t build Zeta because I assumed the economics were impossible. The mental model for AI code generation is a meter running the whole time: the model writes every file, every route, every test, token by token, and you pay for all of it. At that shape, generating a real full-stack app — and re-generating it on every edit — looked like it would cost dollars a build and tens of dollars a day per user. You can’t offer “proven every time” if proving means re-running an expensive model over the entire codebase on every change.

That assumption was wrong, and the reason it was wrong is the whole product.

Zeta doesn’t ask a model to write your app. It asks a model to write one thing — the ISL spec: a compact declaration of your entities, roles, lifecycles, and rules. Everything after that is deterministic. The spec compiles to Postgres and a Next.js app through plain code generation, and the proof gate runs as ordinary logic against a real database. No model in the loop. No tokens.

So a full build is essentially one model call: about 19.8k tokens in, 6.9k out. On the fast lane that’s gpt-oss-120b running near 3,000 tokens/second — the spec lands in a couple of seconds. Then deterministic machinery takes over and does the expensive-looking work for free.

These aren’t estimates. They’re measured from 236 real builds and 952 model calls recorded over two weeks, priced against our cost table:

A full, proven application costs about two cents to build. The median is a penny. The worst build we have ever recorded was sixteen cents. Two weeks of every build anyone ran came to $5.37, total.

The lane only shifts it slightly — a heavier reasoning model writes a richer spec, not a bigger bill:

Here’s the line that changed how I thought about the whole thing: the proofs cost nothing. Clause-coverage, state-machine liveness, cross-tenant RLS isolation, RBAC matrices, proven-safe migrations with data-loss checks — every one is deterministic logic running against a real Postgres, not a prompt. Zero tokens.

That’s why “proven every time” is a real offer instead of a marketing line. We’re not sampling a few builds for a quality check we can afford. We run the full gate on every single build, because running it again is free. The expensive part of trustworthy software — verifying it — is the part that doesn’t move the meter.

Edits in the studio follow the same shape: a cosmetic change rewrites one page file (one small model call); a structural change re-authors the spec and deterministically re-emits, then re-runs the full proof. Estimated cost to run:

One caveat I’ll state plainly: those edit figures are inferred from comparable token profiles, not directly measured yet. Builds emit precise telemetry; the edit route doesn’t — so we can quote build cost to the cent but only estimate edit cost. Instrumenting it is on the bench now, and when it lands these become real per-edit numbers and a real first-try ship rate.

And to be straight about an earlier claim floating around: any “$4–$250 per build” figure was arithmetic garbage, off by a hundred to a thousand times. The numbers on this page are the ground truth.

Cheap generation isn’t the interesting part — everyone’s generation is getting cheaper. The interesting part is that the verification is free, because we moved it out of the model and into deterministic code. That’s what lets us prove every build, gate every ship, and roll back any edit that fails — without the cost of proof ever showing up on the bill.

Two cents to build it. Nothing to prove it. That’s the economics that make “proven before you ship” something we can actually mean.

Want the mechanics behind the proofs themselves? Read “Proof, not vibes”.