Last week, I posted about changing our mindset when it comes to the new AI-driven development mode. I questioned whether reusability, maintainability, documentation, and architecture can remain immutable, or whether they too have to evolve. The post got a lot of traction — and a lot of pushback. I read every response carefully. The skepticism is legitimate. These are principles we have built careers on, and they deserve a deeper conversation. So rather than argue the point in the abstract, I did what engineers do: I ran an experiment. I wanted to see for myself what an agentic programming language could actually look like if you took the premise seriously. This post is about that experience.


It was a vision compelling enough that I am convinced it needs to exist.

Not built by me. I do not have the expertise. But I can see the value clearly enough to argue for it. This is the path toward truly liberating AI to build software autonomously: bug-free, highly performant, unconstrained by paradigms designed for human cognition. My thesis is simple: AI is hungry for its own language, and giving it one could unlock improvements that dwarf anything we have achieved by optimizing within human constraints.


The experiment

Claude Opus was my first collaborator. It produced ideas that felt genuinely novel, until, under some gentle pressure, it began naming its influences. Languages and projects I had never encountered: Unison, Lean 4, Idris 2. Others I had heard of but never explored: Smalltalk, JetBrains MPS. The fact that AI could synthesize across this entire landscape, pulling the best ideas from obscure corners of programming language theory, was itself proof that AI is uniquely positioned to design its own language.

Then I ran the same prompt across six different AI systems independently — Claude, ChatGPT, Gemini, Perplexity, Copilot, and DeepSeek — each in a clean session, with no cross-pollination between them. I then consolidated the responses, mapping each proposal against the others to surface what they agreed on, what they diverged on, and what was unique to each model. The full breakdown is in the comparison table linked at the end of this post. But the short version is striking: despite wildly different architectures, training data, and stated design philosophies, they converged on many of the same fundamental answers.


Not superficial tweaks. A complete overhaul.

The changes AI proposed are not cosmetic. They cut across every layer of the software ecosystem: tooling, repositories, storage, the entire development lifecycle. This is a ground-up reimagining of the SDLC as we know it.

And that makes sense. AI operates under fundamentally different constraints than humans do, with different memory models, different failure modes, a different relationship to uncertainty and parallelism. A language designed around human limitations will always be a poor fit. A complete overhaul is not radical. It is the logical conclusion.

This does not mean it all has to happen at once. There is a sensible path of incremental steps toward this future. But that is an implementation detail. Here, I want to focus on the destination.


Strong opinions, clearly held

Across the designs, a few convictions came through immediately and forcefully.


The striking convergence

Here is what is most significant: all six AI systems, prompted independently, arrived at the same core abstractions. Graph-structured representations, probabilistic and confidence types, implicit parallelism, and the elimination of null, mutable assignment, exceptions, and unit tests.

That last one deserves to be said plainly: every model independently proposed replacing unit tests with formal proofs or constraint-based verification. The implications are profound. Unit tests are inherently incomplete — they verify behavior at specific inputs, leaving the entire untested space as a silent liability. A proof verifies behavior across all possible inputs simultaneously. It is the difference between sampling and certainty. In practice this would mean a compiler that refuses to emit code until correctness is established — not merely asserted at a handful of hand-picked cases. The tooling to get there already exists: dependent types, refinement types, and SMT solvers have been making this tractable for years. What AI adds is the ability to generate those proofs automatically, removing the one barrier that kept formal verification confined to academia. If a language is designed so that programs are simultaneously their own spec and their own proof — as all six systems proposed — unit testing does not become less important. It becomes obsolete.

When LLMs design for themselves rather than for humans, they converge on strikingly similar answers.

The key divergence

The proof commitment spectrum. DeepSeek required formal proof before compilation. Claude favored symbolic verification. Perplexity and Copilot leaned toward statistical, evidence-based confidence. ChatGPT and Gemini leaned toward synthesis: you declare constraints, and the system finds an implementation.

The deeper insight, though, is this: when AI systems design for themselves, they all independently recognize that the gap between specification, implementation, and proof is artificial. It exists because humans cannot hold all three in mind simultaneously. Every language here, in different ways, collapses that gap, producing programs that are simultaneously their own spec, their own proof, and their own documentation.

That convergence may be the most reliable data point we have about how AI systems actually represent computation internally.

I present to you

Lattice