Bend Arrives: A Fast Language That Blocks AI Mistakes with Proofs

The programming language Bend, which blocks AI mistakes with proofs, has been released. It runs fast on both CPU and GPU and features Python-like syntax. At its core is a type checker that functions as a proof checker. Reported by nicolas-siplis on Hacker News (Best), it attracted attention with 218 points.

The official site describes the language’s positioning as follows.

Bend a fast language that blocks AI mistakes via proof C speed · CUDA parallelism · Lean proofs · Python syntax

Behind the development is the spread of development with generative AI. Even as humans stop reading and writing code directly, a way to convey intent without ambiguity is needed. Laws provide a more precise description of intent than natural language. Proofs verify whether an implementation follows instructions. A fast runtime handles execution. Bend was presented as a language that provides these three elements as one.

Fast Execution From Single Core to GPU

Bend is translated to native code. On a single core, it runs at speeds close to C. The same executable runs on 16 cores. On GPUs, speedups of up to 100x over a single core were shown. Comparisons on Apple M4 Max showed lower values as faster.

No scripts, locks, or kernels need to be written for parallelization. If a process is split in two, the runtime distributes the calls across available cores. After completion, it combines the results. As an example, pow2.bend was shown running on 4,096 GPU cores. This reveals a design that absorbs CUDA parallelism into the language itself.

This design keeps users from being aware of differences between CPUs and GPUs. The same code runs on multi-core CPUs and GPUs. It reduces the configuration burden when using GPUs. It is a structure that makes it easy for AI agents to direct parallelization. As Intel Arc Alchemist to Get HuC Media Acceleration With Xe Driver shows, GPU acceleration depends on driver-layer support. Hiding distribution and combining on the language side has great practical significance. Combined with infrastructure improvements seen in Linux 7.3 to Stably Support Intel Nova Lake S Integrated GPU, it broadens the scope of operation.

Designed to Keep Proof Checking Under One Second

Bend’s type checker is a proof checker. It holds a position similar to Lean and Rocq. Existing proof checkers can take minutes on medium-sized codebases. Bend finishes checking in about a second at most. It is fast enough for AI agents to check on every change.

Comparisons on Apple M4 Max also emphasized the short checking time. Fast checking is directly tied to the development loop. Generation and checking can be repeated in short cycles. It enables early detection of errors. It is well suited for autonomously fixing code.

Speeding up proof checking is not merely a matter of convenience. In agent-driven development, the number of attempts determines quality. If checking is slow, iteration stalls. If checking is fast, maintaining laws becomes practical. Bend is designed around this cycle.

Blocking AI Mistakes by Defining Laws

Bend’s greatest feature is blocking mistakes with laws. It addresses the challenge of adopting untrusted generated code without human review. Laws are declared in LAWS.bend. After that, AI cannot emit code that violates the laws. Emission becomes mathematically impossible, treated as a theorem.

As a concrete example, laws for a simple game were shown. LAWS.bend describes conditions under which winning is impossible. It replays any sequence of moves from the initial state. It defines never reaching a winning state as equivalence with False. In PROOF.bend, a proof written by AI shows that the laws hold.

The example covered a feature addition for board wrapping. Without laws, the mistake was merged as-is. With laws, the AI was forced to retry until it built walls and proved the laws held. As a result, integration of the mistake was blocked. It was described as a mechanism that backs up AGENTS.md. The instruction “do not make mistakes” becomes subject to type checking.

Attempts to have AI handle large-scale rewrites already exist. Bun Ports 530,000 Lines From Zig to Rust With Claude Fable 5 is a case involving a port on the scale of 530,000 lines. The larger the scale, the closer human review comes to its limits. Mechanical guarantees through laws and proofs offer a strong alternative.

Installation Steps and Integration With AI Agents

Installation consists of three steps. First, run the install command. Second, add usage guidelines to AGENTS.md. Third, enjoy fast, mistake-free applications.

The install command is as follows.

curl -fsSL https://bend-lang.com/install.sh | sh

The additions to AGENTS.md consist of four items. When using Bend, learn with bend guide. Keep important rules in LAWS.bend. Run bend PROOF.bend before emission. Parallelize code wherever possible. Then you can use it by instructing “use Bend”.

The key to operation lies in writing laws. State conditions that must never be broken explicitly as laws. Actively instruct parallelization as well. Incorporate running proofs into the emission process. This makes generation and verification a routine process.

Differences From Existing Languages and

Design Background

Bend targets speed, verification, and parallelism at the same time. It aims for C-like speed. It builds CUDA parallelism into the language. It handles Lean-style proofs with Python-like syntax. Few existing languages combine all three.

Traditional proof assistants are rigorous but heavy. General-purpose languages are fast but offer weak guarantees. Parallel languages impose a heavy writing burden. Bend fills this gap. It also differs in assuming AI agents as users.

Economic assumptions were also made explicit. In a post-AGI economy, humans will no longer write or read code. Even so, what AI should execute must be defined. Laws were placed as a means to eliminate the ambiguity of natural language. Proofs were placed as a means to verify the correctness of implementations. A fast runtime handles execution. The language design responds to changes in the development system.

Editorial Opinion

On short-term impact. The fact that proof checking finishes in about a second will increase iteration speed in agent development. If writing laws is incorporated into the emission process, retries of generated code will become routine. Automating parallelization will broaden the use of multi-core CPUs and GPUs.

On the long-term perspective. Separating laws and proofs will change the relationship between specification and implementation. If natural-language instructions are replaced by laws, reusable assets of intent will accumulate. Combined with a fast execution base, circulation of verified code may advance.

Questions from the editorial team. There is the issue of who guarantees the correctness of the laws themselves. If the laws are wrong, false guarantees will be mass-produced. Support for creating laws and methods for verifying them are called into question.

References

• “Bend – A language that blocks AI mistakes via proof, on CPU and GPU”, by nicolas-siplis — Hacker News (Best), 2026-09-17T20:36:13.000Z (ARR)
• Source URL: https://bend-lang.com/