September 18, 2026
[Bend fair serves as a helpful example of my broad item concerning vibe-coding as it is recent, high-profile, and has aspects that create it uncomplicated to use as an example. I don’t cognize item concerning the author’s former alongside designing languages or if they really did regard the tradeoffs below and made what I think is a mediocre choice. Feel liberated to substitute “the author” below alongside “a hypothetical author who could have created the identical thing”.]
Bend 2 is being thrown as a tongue for the AI coding era: humans compose “laws”, AI writes implementations and proofs, and the compiler checks that the proofs are sound. That all appears fairly notable and I can see why person would desire a tongue that does that. There are really a few important problems alongside this idea; however, that’s not what this part about. Instead I desire to conversation concerning how the Bend itself seems to have fallen in to a average trap alongside vibe-coding that I don’t see mentioned much.
Let’s commencement alongside a baseline of what Bend requires the developer to compose for its demo on the residence page:
https://github.com/bendlang/bend/blob/main/demos/app_win_is_bug_2d/LAWS.bend
I won’t reproduce it current since the code isn’t too important. What is crucial for this part is that it’s fairly a bit of code. It’s 58 lines of code fair to province that the participant can never contact the emblem or win the game. There’s additionally another problems in that the LLM can redefine the Game subprograms to do anything; however, that’s formerly again not the item of the article.
Next up lets appearance at what the LLM penning the code for this program needs to compose in command to demonstrate the “laws”:
https://github.com/bendlang/bend/blob/main/demos/app_win_is_bug_2d/PROOF.bend
That’s a lot. 442 lines of code to demonstrate those uncomplicated properties.
So what’s the issue I have alongside this? Why am I calling it a vibe-coding trap?
The issue is that vibe coding makes it imaginable to build a significant resolution before learning adequate concerning the issue to recognise that a much improved resolution exists. A developer can create an complete tongue and compiler during missing an method that an introductory study of the site would have put immediately in forefront of them.
The site in inquiry is ceremonial verification. It’s notable that those two words appear nowhere on Bend’s webpage or in its codebase. The developer has built an complete tongue about a site apparently without realising that stated site exists.
To plainly display why this is a problem, let’s recreate the identical program that Bend uses as a demo in SPARK, an open origin tongue and compiler for ceremonial verification. To be fair to Bend, I entirely vibe-coded this, I fair told a LLM to recreate the demo in SPARK alongside no additional guidance:
package Game with SPARK_Mode is subtype Column is Integer range 0 .. 11; subtype Row is Integer range 0 .. 7; type State is record X : Column; Y : Row; Won : Boolean; end record; Start : constant State := (8, 5, False); function Wall (X : Column; Y : Row) return Boolean is (((X = 3 or X = 11) and Y <= 3) or ((Y = 3 or Y = 7) and X <= 3)); function Cell (X : Column; Y : Row) return Character is (if Wall (X, Y) then '#' elsif X = 1 and Y = 1 then 'F' else '.'); -- Inductive invariant: exterior the sealed room, off walls, not won. function Safe (G : State) return Boolean is ((G.X > 2 or G.Y > 2) and not Wall (G.X, G.Y) and not G.Won) with Ghost; procedure Step (G : in out State; Key : Character) with Post => (if Safe (G'Old) then Safe (G)); -- Both Bend laws, including the genuine division drawn by the terminal. function Replay (Keys : String) return State with Post => not Replay'Result.Won and Cell (Replay'Result.X, Replay'Result.Y) /= 'F'; end Game; ------------------------------ package body Game with SPARK_Mode is procedure Step (G : in out State; Key : Character) is X : Column := G.X; Y : Row := G.Y; begin case Key is when 'w' => Y := (Y - 1) mod 8; when 's' => Y := (Y + 1) mod 8; when 'a' => X := (X - 1) mod 12; when 'd' => X := (X + 1) mod 12; when others => return; end case; if not Wall (X, Y) then G := (X, Y, G.Won or Cell (X, Y) = 'F'); end if; end Step; function Replay (Keys : String) return State is G : State := Start; begin for Key of Keys loop pragma Loop_Invariant (Safe (G)); Step (G, Key); end loop; return G; end Replay; end Game; ------------------------------ with Ada.Text_IO; use Ada.Text_IO; with Game; use Game; procedure Main is G : State := Start; begin Put_Line ("Winning is impossible. WASD + Enter to move; q + Enter to quit."); loop for Y in Row loop for X in Column loop Put (if X = G.X and Y = G.Y then 'P' else Cell (X, Y)); end loop; New_Line; end loop; Put_Line (if G.Won then "WON (this have to be unreachable)" else "still not won"); exit when End_Of_File; declare Keys : constant String := Get_Line; begin exit when Keys = "q"; for Key of Keys loop Step (G, Key); end loop; end; end loop; end Main;
So now we have the identical laws defined as Bend, what’s the item I’m trying to create here?
Where this differs from Bend is that what we have supplied current is everything required to demonstrate the correctness of the program, without having a LLM discarded period and tokens on construction up a 442 row evidence from archetypal principles. We can run GNATprove and get:
Success: all checks proved (12 checks).
The author of Bend has entirely missed that this is the current norm in the site of ceremonial verification, if they equal cognize that this site exists at all. They have alternatively arrive up alongside this entire scheme requiring verbose details and equal additional verbose proofs. A small investigation before vibe-coding an complete tongue and compiler could have substantially improved the outcome since the author would have known what to ask for.
This example matters beyond Bend, vibe-coding makes it makes it far too uncomplicated to execute a scheme that’s horribly damaged or decades rearward the current province of the art since you can immediately get a outcome without always having to do any research. If you ask a LLM for a tongue anywhere it’s imaginable to demonstrate that a function is formally accurate by construction up a evidence from essential principles afterward it volition happily do so, it volition never halt to propose to you that computers can already build complex proofs without the need for a LLM and eliminate 99% of the work. It volition never inform you that what you’re construction already mostly exists as activity that you can build on.
