156 Entities
Compiler/materialization scaling experiment.
Intent Specification Language
BUILD FROM INTENT.
ISL is a formal language for turning software intent into executable systems — with verification built into the pipeline.
IntentControlled visualization — not a live build
Awaiting compile. Numbers below are measured artifacts.
- PARSING
- COMPILING
- MATERIALIZING
- VERIFYING
- RECEIPT
The big idea
SOFTWARE STARTS AS INTENT.
Traditional software tooling starts with code. ISL starts with what the software is supposed to mean and do.
ISL
A formal specification: entities, relationships, policies, workflows, routes, behaviors.
Architecture
UNDER THE HOOD
One pipeline. ISL owns behavior. The compiler emits the system. ShipGate owns the verdict. WholeStack is the company behind the broader platform — not a synonym for ISL.
Deterministic lowering. Models propose. The compiler decides structure.
ISL Scale Lab
HOW FAR CAN INTENT SCALE?
26 entities completed the full Ship/P3 verification pipeline with a verified receipt. Evaluator probes were 133.197s of the 198.883s TTPS.
156 entities / 666 routes / 3,122 files compiled and materialized in ~10 seconds; full Ship verification was intentionally not run.
26 entities completed the full Ship/P3 verification pipeline with a verified receipt. Evaluator probes were 133.197s of the 198.883s TTPS.
docs/platform/ttps-campaigns/ISL-MAX-SCALE-v0.1.md
2626-entity verified
52Routes
317Files
87,859LOC
10.076sEmit
198.883sTTPS
VERIFIED
Verified end-to-end26 entities · P3 PASS · receipt
26 entities · 52 routes/surfaces · 317 files · ~199s TTPS · P3 PASS · verified receipt.
Compile/materializeShip verification intentionally not run
156 entities · 337 relationships · 1,010 fields · 666 routes · 3,122 files · 10.4k lines of ISL · ~10s emit.
Failed experiments stay published
FINDING THE WALL
Scaling is not only successful runs. The current verified workload becomes evaluator-bound because live route probes interact with Next's compile-on-demand behavior.
APPLICATION SCALE
COMPILER✓ scales
MATERIALIZATION✓ scales
VERIFICATIONcurrent bottleneck
EVALUATORroute probes × compile-on-demand
Parallel probes made the system slower. Overlay publishing improved TTPS without changing P3 obligations. We don't optimize benchmarks by weakening verification.
Intent preservation
THE SPEC DOESN'T DISAPPEAR AFTER CODEGEN.
The system retains structured relationships between original intent, generated artifacts, and verification evidence. That is provenance back to the spec — not a claim of cryptographic sealing unless a given receipt says so.
ORIGINAL INTENT
- entities
- relationships
- policies
- workflows
- routes
- behaviors
GENERATED APP
EVIDENCE
VERIFIED RECEIPT
ShipGate
GENERATION IS NOT PROOF.
Generating software is easy to demonstrate. Knowing whether the generated software actually satisfies its intended contract is harder. ShipGate is the verification layer — SHIP / NO-SHIP — and, when the obligations run, a verified receipt.
Simulated checks for the laboratory. A public SHIP still requires a real receipt. Verdicts end at SHIP / NO-SHIP, then — if the pipeline completed — a verified receipt.
Measured values only
BENCHMARK TABLE
Empty cells were not published in the cited artifact. COMPILE ONLY is not VERIFIED.
| Scale | Entities | Routes | Files | LOC | Emit | TTPS | P3 | Verification |
|---|---|---|---|---|---|---|---|---|
| 26-entity verified | 26 | 52 | 317 | 87,859 | 10.076s | 198.883s | PASS | VERIFIED |
| 38-entity verified | 38 | 264 | 393 | — | — | — | PASS | VERIFIED |
| 102-entity compile | 102 | 438 | 2,161 | ~275,792 | 23.565s | — | — | COMPILE ONLY |
| 156-entity compile | 156 | 666 | 3,122 | — | 9.982s | — | — | COMPILE ONLY |
Unpublished
IN THE LAB
Surfaces that exist in the repo. Not public product doors. Not receipts. No download. No Open IDE.
ENTERPRISEISL Studio IDEMonaco workbench at /ide. Sign-in + Enterprise gate. No public Open IDE.DESKTOPDesktop IDEElectron package. Contract-first ISL + ShipGate. Installer not published here.IN THEATERLanding DirectorDirection stage of the one Experience Compiler. Not a second pipeline.ENTERPRISEChange Impact LensSave opens impact + prove. Silent high-risk writes are forbidden.ACTIVEIntent Canvas/canvas architecture plan. Does not mint SHIP.
Experiments
LAB NOTES
Development is not a highlight reel. These are the writeups behind the ladder.
Writing
BLOGS
Field notes and essays published on WholeStack. Lab notes stay on this site. These open the original posts.
When the proof gate met Solidity
We pointed the same proof discipline at smart contracts — and found we could do better than runtime testing. Symbolic execution that proves a property over every input, certificates bound to the deployed bytecode, and a hard line on what we refuse to claim.
Two cents a build: the economics of proof
Zeta writes one spec at ~3,000 tokens/sec, then proves the whole app deterministically. The proving is free. Here's what a verified full-stack app actually costs to run — measured across 236 real builds.
Proof, not vibes: where ISL is headed
What we discovered building ISL — a domain spec language that compiles one prompt into an app whose safety is adversarially proven against a real database — and the roadmap from here.
The pipeline is real
One window of work. Ten agents in isolated worktrees. Twenty commits on main and ~320 green tests proving that natural language → cryptographically verified TypeScript is no longer a slide deck.
The bet behind ISL
A year building a specification language for AI code. Natural language is the drift, not the interface — here's the thesis, what already ships, and what comes next.
Can we actually ship safe AI code?
A night with the gate, Intent Specification, and the wall ahead — cloning real Next.js repos, hand-writing OAuth specs, reading 50MB of bundled CLI, and asking the question the vibe-coding decks won't answer.
The origins of ISL
From VibeCheck's truthpack to a compiler contract: why AI-generated code needs an executable intent contract, and how ISL came to be.