Glonce

Bend proposes a proof-checked language to stop AI coding mistakes

toolsThe Glonce editorsHacker News🔥78Glonce rating78Impact60Novelty65Relevance95Surprise55Players25Credibility82

Bend is a programming language pitched around a specific problem: once AI agents write most of the code, humans need a way to constrain what those agents build without reading every line themselves. Bend's answer is to fold proof checking into the type checker, the same approach used by the proof assistants Lean and Rocq. A developer writes rules, called laws, in a file named LAWS.bend; from that point on, the source page states, no AI can ship a single line that breaks a declared law, ever, because merging a bug becomes mathematically impossible rather than merely unlikely. The page frames this as a theorem, not a promise. The worked example is a game board: a law states that no sequence of moves can lead to victory. When an AI agent was asked to make the board wrap around, the page says that without LAWS.bend the resulting bug shipped, while with LAWS.bend the AI had to retry until it built a wall and proved the law still held. Bend also targets raw performance rather than just correctness. It compiles to native code that, on a single CPU core, the source claims runs nearly as fast as C. The same compiled binary can also run across sixteen cores, or on a GPU, where the page claims it goes up to a hundred times faster than a single core; a demo shown on the page runs a function called pow2 across 4,096 GPU cores without the developer writing any threads, locks, or GPU kernels by hand, since Bend itself splits the work across whatever cores it finds and joins the results back. On proof-checking speed, the page contrasts Bend with Lean and Rocq: those tools can take minutes to check a mid-sized codebase, while Bend takes a second at most, which the page says makes it practical for an AI agent to check its own work after every change. The workflow is meant to plug into existing agent setups: a snippet added to a project's AGENTS.md file tells an AI assistant to run 'bend guide' to learn the language, keep laws in LAWS.bend, and run 'bend PROOF.bend' before committing, plus to parallelize code wherever possible. Underlying the language are two papers referenced on the page: BendTT, described as an affine dependent type theory forming Bend's core, and BendRT, a parallel runtime for CPUs and GPUs that acts as the language's virtual machine. The page states Bend works best on back-end code, on Linux and macOS, and describes the language as still evolving, asking users to expect bugs and report them.

Key facts

  • Bend's type checker also functions as a proof checker, in the manner of Lean and Rocq, checking a mid-sized codebase in a second at most versus minutes for those tools.
  • Rules called laws are declared in a LAWS.bend file; the source claims no AI can merge code that breaks a declared law once it exists, framing this as a mathematical guarantee rather than a policy.
  • The same compiled binary runs on one CPU core at a speed the page compares to C, on sixteen cores, or on a GPU, where it claims up to a hundred times the speed of a single core.
  • A demo on the page runs the pow2 function across 4,096 GPU cores with no manually written threads, locks, or GPU kernels.
  • The language is built on two referenced papers, BendTT (an affine dependent type theory) and BendRT (a parallel CPU/GPU runtime), and the page describes Bend as still evolving with bugs to be expected.

Why it matters

Bend targets a specific anxiety around AI-written code: that as agents generate more of a codebase, the human reviewer's ability to read and catch every mistake breaks down. Instead of relying on review, Bend tries to make certain classes of bugs impossible to merge by turning constraints into proofs the compiler checks automatically, combined with a compiler that spreads the same binary across CPU cores or a GPU without the developer writing parallel code by hand.

Who it affects

The page addresses developers and teams who let AI coding agents write and modify code directly, particularly on back-end projects where Bend says it works best, on Linux and macOS. It is aimed at anyone who wants an automated, provable check on agent output rather than depending on manual code review to catch what an AI assistant gets wrong.

How to use it

Bend is installed with a curl command piping install.sh into a shell. Usage centers on adding a short block to a project's AGENTS.md instructing an AI agent to run 'bend guide' to learn the language, keep rules in a LAWS.bend file, run 'bend PROOF.bend' before committing, and parallelize code where possible; a developer can then simply tell the assistant to 'use Bend.' The page's own guide, printed by running 'bend guide,' documents the full language.

How solid is it

The claims on the page, that Bend runs nearly as fast as C on one core, up to a hundred times faster on GPU than on a single core, and that its proof checker runs in a second at most versus minutes for Lean or Rocq, are stated without a described benchmark methodology, hardware, or workload behind them. The language rests on two referenced papers, BendTT and BendRT, describing its type theory and parallel runtime, but the page itself gives no named author, founder, or company, and no release date or version number.

Risks and caveats

The page explicitly calls Bend still evolving and tells users to expect bugs and report them, which sits alongside its claim that merging a law-breaking change is mathematically impossible. The flagship 'Claude, make the board wrap around' example is presented as an illustrative, hypothetical prompt rather than a documented real incident with a named user. No performance benchmark details are given, so the speed and proof-checking-time claims cannot be independently checked from the source alone.

“Merging a bug is mathematically impossible: it is a theorem.”

— Bend project page