AI Coding Live News

Google DeepMind Unveils AlphaProof Code: Gemini 4 Carbon Agents Write 6M+ Lines of Lean in 4 Weeks to Formally Verify Signal Protocol Down to ARM Machine Code

On November 10 Google DeepMind introduced AlphaProof Code, a multi-LLM agentic framework for formal verification: human experts and models turn security goals into formal specifications, then agents powered by Gemini 4 Carbon carry out the proofs. The team used it to prove key security properties of the core Signal protocol implementation, such as forward secrecy and post-compromise security, all the way down to the AArch64 machine code running on devices. DeepMind says this is the first time the implementation of a widely deployed protocol has been formally verified at this depth by any method, with or without AI: more than 6 million lines of Lean proofs in four weeks, with only about 1% needing human review. Specs and proofs are open source on GitHub, and Signal CTO Ehren Kret endorsed the result.

Google DeepMind Unveils AlphaProof Code: Gemini 4 Carbon Agents Write 6M+ Lines of Lean in 4 Weeks to Formally Verify Signal Protocol Down to ARM Machine Code

Key Takeaways

  • Scale: agents produced 6M+ lines of Lean proofs in 4 weeks during October 2026, all machine-checked by Lean (vendor figure)
  • Human share: after agent self-audit only about 1% of the proofs were flagged for human review; every specification was reviewed by human experts
  • Depth: proofs reach the AArch64 machine code, covering the protocol core including the PQXDH handshake and Triple Ratchet, without trusting the Rust compiler
  • Negative test: the team reintroduced 2 real, previously fixed bugs into an isolated build, and the system produced machine-checked proofs that those versions were insecure
  • Open source: paper, Lean specs and proofs are published at google-deepmind/code-verification, with a public endorsement from Signal's CTO
Read full story

X Discussion: Vercel CEO Guillermo Rauch Says AI Will Rewrite All Human-Made Software, Sparking Debate on Formal Verification and Rewrite Risk

On November 5 Guillermo Rauch posted on X that most human-made software was slow, insecure and under-specified, and that AI will rewrite it all, many times, then formally verify, load test and harden it: "the true birth of software engineering." The post drew 3,000+ likes, 270+ reposts and nearly 100K views. Supporters cite from-scratch AI rewrites; critics warn that missing specs and human review still matter. This is a personal opinion, not a Vercel announcement.

Key Takeaways

  • Rauch's post (Nov 5, 02:22 UTC) had about 3,060 likes, 272 reposts, 681 bookmarks and ~99K views when fetched
  • Core claim: AI will rewrite human software "many times", formally verifying, load testing and hardening it, and replacing memory-unsafe foundations
  • An hour earlier he shared Vercel Security Review figures: 6,817 vulnerabilities found in 24 hours, 580 critical/high, 1,411 already patched by Agent (vendor-reported)
  • Pushback: rewriting under-specified code can just ship the same wrong behavior faster, and formal verification moves bugs up an abstraction level rather than eliminating them
  • This is an opinion thread, not an established fact or official roadmap
Read full story
Linked Models & Agents:

X Discussion: Grok Bot Engineer poteto Calls Adversarial Agent Code Reviews "Mostly a Waste of Tokens" and Argues for Empirical Plus Formal Verification Instead

On November 3, @poteto (lauren), whose bio says she works on Grok @bot at SpaceXSI, is on the React Compiler core team, and previously worked at Cursor, Meta and Netflix, posted what she called "maybe a hot take": she now considers adversarial reviews mostly a waste of tokens and thinks those tokens are far better spent on empirical combined with formal verification. She says she has updated her agent skill pack pstack to use its interrogate (multi-model adversarial review) skill less and may eventually remove it. She adds that she has found very little value in code review in the abstract, because agents tend to get lost in nitpicks and YAGNIs. The post drew about 906K views, 9,227 likes and 5,538 bookmarks. It is a personal opinion that sparked debate over the value of AI code review.

Key Takeaways

  • Opinion (personal, not an official finding): adversarial reviews are "mostly a waste of tokens"; empirical plus formal verification is the better use of them
  • Action: the author says she has made pstack use the interrogate skill less and may remove it; at fetch time the public pstack folder in GitHub cursor/plugins had no commits after October 27, so the change is not visible there yet
  • What interrogate is: per its public SKILL.md, it spawns one read-only reviewer per configured model (defaults Claude Opus 5.5 xhigh and Grok 4.7 xhigh fast) to attack the diff, then sorts findings into Act on, Consider, Noted and Dismissed without auto-applying fixes
  • Author (per her X and GitHub bios): engineer on Grok Bot at SpaceXSI, React Compiler core team, previously at Cursor, Meta and Netflix
  • Reach: about 906K views, 9,227 likes, 5,538 bookmarks, 668 replies, 356 reposts and 210 quotes
Read full story

GitHub Next Releases PDD Kit: Provable Specification Enforcement for Coding Agents to Eliminate Edge-Case Regressions

GitHub Next officially released PDD Kit (Property-Driven Development Kit), establishing a formal verification toolkit tailored for autonomous coding agents. Addressing the pervasive reliability gap where agent-generated code passes isolated unit tests but crashes on subtle edge cases, PDD Kit combines property-driven specifications with automated formal solvers. Instead of testing arbitrary sample inputs, PDD Kit mathematically proves that agent code adheres to rigorous invariant specifications across every possible input, preventing regressions and elevating coding agents from probabilistic generation to provable correctness.

GitHub Next Releases PDD Kit: Provable Specification Enforcement for Coding Agents to Eliminate Edge-Case Regressions

Key Takeaways

  • GitHub Next releases PDD Kit to eliminate edge-case flaws in agent-generated code via automated mathematical proofs
  • Pioneers 'proofs for every input', replacing fragile, underspecified unit test samples with comprehensive invariant verification
  • Eliminates deadlocks, boundary index out-of-bounds, and state desynchronization in agentic refactoring workflows
  • Provides an indispensable verification foundation for deploying autonomous coding agents into mission-critical production systems
Read full story
ADSponsored