The cost of writing software collapsed. The cost of trusting it didn't. That gap is the biggest problem in software right now.
AI writes code, tests, and scaffolding at superhuman speed. That's real. But ask anyone shipping software at scale: are you actually going faster?
Imagine a factory where robots now do all the assembly — 10x faster. Amazing! But someone still has to inspect every product, check for safety, make sure it all fits together.
Those inspectors are now the bottleneck. The factory can build faster, but it can't ship faster.
Sam is building a tool that lets the robots prove each product is correct as they build it — so you don't need as many inspectors.
Spell-check doesn't help with "their vs. there" — you still need a human to read the whole thing. Sam's tool is like grammar-check that catches the things spell-check misses, automatically.
Current AI coding tools are spell-check. Sam's tool is the grammar-check layer that's missing.
Your banking app, your car's navigation, hospital records, airline bookings — all software. AI is writing more and more of it. Someone needs to make sure it's correct.
Sam's tool does that automatically, for all possible cases, not just the ones you think to test.
Sam's tool becomes the standard way software teams verify their code is correct — like how Excel became the standard for financial calculations. Every team uses it, because the alternative is trusting code you can't fully check.
AI code generation is exploding. Trust is collapsing. The gap between the two is the opportunity.
Developer trust in AI code dropped from 40% to 29% while adoption rose from 67% to 84%. These lines are diverging fast.
The trust infrastructure for the AI coding era. As AI writes more code, the market for verifying that code grows proportionally. This isn't a feature — it's a new category.
Adoption flywheel
Production performance
CI/CD integration
AI made generating academic research cheap. Peer review became the bottleneck. Terence Tao's answer: formal verification. Let machines check proofs instead of waiting for humans.
We're doing the same thing for software.
Each removed a class of human review by making correctness automatic. We do the same for code verification.
Verifying a property is computationally cheap (P). Discovering where to assert it, what annotations to write, how to restructure code for provability — that's the hard part (NP-like).
Traditionally humans did the NP part. That's why formal methods were expensive — not because verification is hard, but because annotation authoring is hard.
AI agents change this equation entirely.
Prove user input never reaches SQL without sanitization — across all code paths, not just tested ones.
Prove external API calls only happen through the integration layer. No backdoor imports. Enforced at compile time.
Prove idempotency, purity, commutativity of specific functions. Mathematical guarantees, not test coverage.
C4 architecture diagrams where every arrow is a verified property. Documentation that can't drift from reality.
Abstract interpretation over all possible inputs. Not fuzzing — mathematical proof.
Annotations embedded in code using familiar TS patterns. Zero new language to learn.
Top-down AND bottom-up analysis. Traditional static analysis only goes bottom-up.
Self-hosted validator. Production-ready compiled evaluator for CI/CD performance.
AI agents generate annotations (the NP part — now cheap). The framework verifies them formally (P — always cheap). Each verified property enables inferring more properties. And here's the key:
The agent can restructure code to make properties more provable.
Each refactor makes more things provable. Each proof constrains the space of possible bugs. The system gets more certain over time, not less. This is the opposite of how testing works — tests give diminishing returns. Proofs compound.
You don't need the same level of trust when the system checks correctness.
Terence Tao — Fields Medalist, on using Lean for formal verification in mathematics
AI made generating mathematical conjectures cheap. Peer review became the bottleneck. Lean replaced peer review with formal verification. We apply the same principle to software: replace code review with formal verification.
Each page explores a different angle.