The pipeline is real

A coding agent in 2026 produces something that looks like working code and hands it to a reviewer. The reviewer is the verifier. That handoff is the whole gap. ISL closes it by slipping a small formal contract between the prompt and the implementation, then grading the implementation against that contract. What you hold at the end is not a green CI badge — it is a signed proof bundle.

Most of the substrate was already sitting in the monorepo: 263 packages, a parser, a typechecker, codegen, a verifier, a dashboard, a VS Code extension. What was missing were the seams. Codegen emitted handler bodies marked // TODO in place of real preconditions. The proof schema carried a signature field with nobody to sign it. The MCP server exposed verify but not generate. stdlib-database was type definitions with no runtime behind them. This window of work was about sewing those seams shut.

The artifact at the end isn’t a green check. It’s a signed proof bundle.

Before a line of code, I sent eight independent agents into the repo with a single job each: map one slice and come back with file:line evidence on what was real and what was a stub. The recon came back tight.

Natural language to ISL works — the spec generator wraps Claude in a validation-and-repair loop. ISL to TypeScript emits a buildable Next.js project, but every business-logic body is a // TODO. Codegen imports zero stdlib effects. The proof schema has a signature field but no public API to produce one. stdlib-database is types only. stdlib-rest-api is an empty manifest. The dashboard has a prompt page, but auth lives apart from the portal. Each report ended with one line: the BLOCKING GAP. Ten gaps came back. Ten builders went out.

The builders spawned into parallel git worktrees. None of them could see another. Each owned a conflict-free slice and committed back through the ShipGate firewall gate. Where the gate fired on a pre-existing false positive — a regex literal inside a secret-detection function that happened to contain the word password, an example URL buried in an LLM prompt template — the fix was a narrow // shipgate-ignore directive on the exact line, with a one-line reason. SKIP_SHIPGATE_HOOK was used zero times.

What landed:

• stdlib-database — a real Postgres adapter with pooling and transactions, plus an in-memory adapter for tests. 50 tests pass.
• stdlib-rest-api — a typed route runtime with Express and Next.js App Router adapters, Zod input and output validation, and precondition and postcondition runners. 33 tests pass.
• proof — Ed25519 signing over canonical JSON, keyId binding, algorithm pinning, and an offline verifier. 21 tests pass.
• codegen-fullstack — handlers now emit real precondition branches, real postcondition runners, real error variants mapped to HTTP status, and stdlib imports. The // TODO stubs are gone. 39 tests pass.
• parser, typechecker, semantics, codegen — discriminated union types threaded end to end, with TypeScript narrow-type guards on the emit side.
• mcp-server — generate_isl_from_prompt and generate_typescript_from_isl tools, with a secret scrubber that strips sk-*, ghp_*, and xoxb-* before the prompt reaches an LLM. 31 tests pass.
• vscode — shipgate.intentBuild and shipgate.buildFromPrompt wired into the command palette. The sidebar prompt surface is no longer dead.
• portal and dashboard — an auth bridge over an HMAC-signed webhook, plus a /redeem?license=<JWT> route that drops a user from Stripe checkout straight into /dashboard/vibe with Pro entitlements.
• cli — a 35-test deterministic end-to-end test for shipgate vibe, driven by a SHIPGATE_LLM_STUB fixture so CI needs no API key.

Once the new packages landed, the build chain surfaced TypeScript errors that had been hiding under the turbo cache for months. A second pass cleared them.

• stdlib-auth — seven pre-existing errors gone. ZodEffects narrowed correctly, the Drizzle interface typed without this returns, AbortSignal.timeout pulled from the right lib entry.
• isl-verify — fifty-one pre-existing errors gone. The full tsc declaration build is back in the package’s build script.
• shipgate-status — the Astro dynamic confirm route moved to hybrid SSR via @astrojs/node.
• parser — 56,564 passing tests up to 56,830. Zero failed.
• typechecker — nineteen assertion failures down to zero. One fixture (valid/all-features.isl) was honestly XFAIL-listed with a reason rather than quietly weakened.

Here is the path a prompt walks, from English to a signed proof on disk. No stage is mocked; the only thing standing in for the model is a canned fixture so the run is reproducible.

# 1. natural language
prompt = "Build a todo list API with auth in TypeScript"

# 2. LLM -> ISL spec (with validation + repair)
  spec-generator (Claude / GPT)
  spec.isl

# 3. ISL -> buildable Next.js project
  codegen-fullstack
  app/api/todos/route.ts      # Zod + runPreconditions
  app/api/todos/[id]/route.ts
  prisma/schema.prisma
  lib/auth.ts                 # JWT via @isl-lang/stdlib-auth
  package.json, tsconfig

# 4. quality gate
  tsc --noEmit + CodeQualityGate

# 5. verify against spec
  verifier (SMT, PBT, runtime, temporal, reality)
  verdict = SHIP | NO_SHIP | REVIEW

# 6. sign
  @isl-lang/proof signProof (Ed25519)
  shipgate-proof.signed.json

With the canned ISL fixture standing in for the model, the whole pipeline runs in about 137 seconds end to end, identical output across runs. 35 of 35 tests pass; the seven skipped are the real-LLM path that needs an API key.

This is the artifact partners actually ask for — not a screen recording, not a fixture-driven slide. A deterministic CI signal that says, plainly: from a prompt, this pipeline produces a buildable TypeScript project with real precondition checks, real error envelopes, real stdlib runtime imports, and a verifier that returns a verdict and a signed proof.

Real:

• A working NL → ISL → TS → signed-proof pipeline, end to end.
• Ed25519 proof bundles over canonical JSON, regulator-readable and verifiable offline.
• Five entry surfaces — CLI, VS Code, MCP, GitHub Action, hosted dashboard.
• ~320 new green tests across the new surfaces.
• 20 commits on main, with no safety bypass on a single one.

Not yet:

• Eval data. The spec generator works, but how often the emitted ISL matches human-written ground truth is unmeasured. Until we publish that number against fifty real prompts, “verified AI code” is a claim, not a moat.
• Proof against real codebases. Signed proofs running on production code in regulated domains — finance, healthcare, defense. That is the distance between working tech and a category-defining standard, and it’s walked one real codebase at a time.
• SOC 2 Type II, SSO, SCIM, self-hosted deploy. Listed in product.json, mostly implementation-ready, not yet shipped.

The infrastructure is real. The pipeline is deterministic. What it needs now is not more code — it is distribution, and proof of accuracy on real prompts at scale. The spec generator works; how often the emitted ISL matches a human-written ground truth is the number we’re measuring next, against fifty real prompts. Until that number is public, “verified AI code” is a claim, not a moat — and we’d rather earn it than assert it.

The interesting frontier from here is regulated work — finance, healthcare, defense — where “the reviewer is the verifier” is simply unshippable, and a signed proof bound to the code is the only thing that clears the bar. That’s the distance between working tech and a standard, and it’s the distance we’re spending the next leg closing.

The bet was that natural language is the drift, not the interface. The pipeline is the proof that the bet can be built. The next leg is whether enough people care.

Read the previous field notes: The bet behind ISL, Can we actually ship safe AI code?, and The origins of ISL.

See it for yourself: start from a proven build & browse what’s been proven