Agents write most of your code now.

At Uber, 65–72% of merged code is AI-generated, and agentic tools took over in a single quarter. Every serious engineering org is on the same curve.

Speed was never the problem.

An agent can rebuild a subsystem you already have, skip the review your method requires, and ship code that logs what it never should — while every check prints green. The expensive failure is invisible for weeks.

The control plane for AI‑assisted development.

Your method — stages, gates, rules — encoded as data the pipeline enforces. Not a wiki nobody reads. Not a convention agents can't see. The same rules for your people and your agents, with the same audit.

Start with one sentence.

The intake reads what it can from your words and asks only what's left — a courier dashboard gets ~20 questions, legal work with uploads gets 24, four of which exist only because it's legal work with uploads. Six irreversible decisions always wait for a human, however clearly you worded it.

Or say it out loud. Dictation is your browser's, not ours — and the page tells you where the audio goes before you press the button, because a disclosure that appears afterwards is decoration.

See the plan before a byte is written.

$ rathvan new ./assetsetu
Plan for AssetSetu — [FOUNDATION, SECURITY, INTEGRATION, CORE_PLATFORM, PRODUCT]
  copy 3 · rewrite 90 · generate 13 · skip 9
  not included:
    V5__marketplace.sql — band BILLING not selected — listings, reviews
Nothing was written — this was a plan.
✓ BUILD SUCCESSFUL  4 gate tests · 4 passed · 0 skipped

Every skip carries its reason. “Where did the marketplace go?” is answerable from the plan itself.

13 stages. 3 gates that name a human.

Prototypes are structurally unable to ship — no production transition exists for the builder. Staging is the ceiling, and that's the point.

It ends at a URL that answers.

$ ./run-local.sh
== starting the database
== building, with the unit suite
== the gate: integration, functional, end-to-end and security
== waiting for it to answer

  AssetSetu is running:  http://localhost:8412
  health:                http://localhost:8412/actuator/health

A build used to end at documents, then at a pull request, then at a repository. Now it ends at something you can open. The last line is a URL that answers, or the run did not succeed — a green run whose URL 404s is the failure this exists to rule out. Press it in the console and the builder does all of it and streams the output; or take the repository and run the same script yourself.

A shared builder refuses — running means executing a build script on a machine other people are using. It says so, and says how to get it: run a builder on your own machine. A refusal that only says “no” teaches nobody anything.

Try it twice, without losing the first.

See the product's screens drawn from its own schema while you're still reading the plan — and they reach the repository only if you accept them. Then fork the run to ask “what if the design had gone the other way”, keeping every document already agreed.

A fork carries the approved documents and nothing it did not earn: no branch, no pull request, no build. Those belong to the run that made them, and a copy claiming them would be a build asserting something it never did. The original is untouched — its record is append-only, and a second opinion must not rewrite the first.

139 capabilities you won't rebuild.

Auth, notification, audit, payments, consent — across 14 domains. The most expensive agent mistake is silently rebuilding one of these, and the intake refuses to let it happen quietly. Declining is allowed; it's recorded.

Use ours, or keep theirs. The code doesn’t change.

ServiceNow, Salesforce, Workday, your accounting package — the question every buyer asks first is whether adopting this means replacing those. For 8 business capabilities the answer is written down, and both halves sit behind one port, so switching later is an adapter rather than a rewrite.

2 we provide. 6 we do not — and the catalogue says which, by name, with the reason. Accounting is deliberately not built: a half‑made ledger is trusted at audit, which is when being wrong costs most. There is no entry called “Oracle”, because that is six systems with six authentication models and one row would hide five projects.

The gaps are the point. A catalogue that claims everything is a brochure; a claim here fails the build if the code behind it is missing — which is how we found our own entry marked “not built” while the adapter had been shipping for weeks.

Nothing leaves. Including the prompt.

Rathvan runs in your cloud account, against your model endpoint — a self-hosted inference server is an environment variable, not a code path. A whole build can produce its plan, its design and its tests without a byte crossing your boundary.

And at the one point every model call passes through, prompts and the retrieved context are scanned. Identifiers, salary, bank details, phone numbers: refused before a vendor sees them, and the refusal names the kind of thing and never the value. That check was a null check until this week — we found it, fixed it, and wrote down that it had been broken.

Your own key, if you want one: a per-user credential goes to the front of the chain, so your spend and your vendor relationship stay yours. Each credential now names the tenant it belongs to rather than inheriting whatever the server was started with, which is what makes one builder safe for two companies.

And the chain is honest about vendors. When one retires a model, runs out of credit or times out, the next answers — and the failed one is skipped until it is worth asking again, so an outage costs one round trip rather than one per request. Every document records which vendor and which model produced it.

It also ships onto your road: Kubernetes manifests and an ArgoCD application instead of a deploy script, where that is how you already deliver.

Every gate exists because a check once said “success” while the work was broken. The failure log ships with the product.

Prove what shipped, don't assert it.

Every generated file is hashed into a manifest and the manifest is signed — the OpenSSF format, detached, beside the repository. Change one byte and rathvan verify names the file; rewrite the manifest to match and it fails on the signature instead. Inside the console, who wrote which line survives too: a human edit is a new version and the model's original is kept beside it.

What it proves: these bytes, that key. What it does not: that the code is correct. A green tick read as “audited” is worse than no tick.

Build things that can't ship what they shouldn't.

No signup for the intake — it runs in your browser and produces a file you own.