> ## Content Index > Fetch the complete content index at: https://barbarosozturk.com/llms.txt > Use this file to discover other available public pages before exploring further. # Why AI Agents Will Build Their Own Programming Language - URL: https://barbarosozturk.com/blog/why-ai-agents-will-build-their-own-programming-language/ - Published: 2026-11-03T23:16:54.000Z - Updated: 2026-11-03T23:16:54.000Z - Description: We only made code readable because people had to read it. As agents write more of it, I think they'll end up with a language of their own, and the danger is how few of us will bother to look. - Author: Barbaros - Tags: Artificial Intelligence Programming languages were built for people. That sounds too obvious to say, but it explains almost everything about them: the variable names, the indentation, the comments, the fact that we still argue about tabs. All of it exists because somebody has to come back later and work out what the code does. That somebody is disappearing from a lot of the process. Google said in April that [75% of its new code](https://www.techspot.com/news/112152-google-ai-now-generates-75-new-code-up.html?ref=barbarosozturk.com) is AI-generated and then reviewed by engineers, up from roughly a quarter in October 2024. Anthropic went from [around 2,500 merged code changes a day in May to more than 30,000 in September](https://simonwillison.net/2026/oct/13/redesigning-source-control-at-anthropic/?ref=barbarosozturk.com). I think agents will end up shaping their own programming language, and I think it'll happen for boring economic reasons. Everyone worries about machines keeping secrets from us. What worries me more is a language nobody bothers to read. ![](https://storage.ghost.io/c/64/81/648165b7-979e-43dd-9c43-02101159f467/content/images/2026/11/image.png) ### Facebook Got There First, In 2017 You probably remember this story. Facebook's research lab built two negotiation bots, Alice and Bob, and the bots [slid into a shorthand of their own](https://techxplore.com/news/2021-07-fact-facebook-didnt-chatbots-language.html?ref=barbarosozturk.com) because nobody had required them to stick to English. The headlines had Facebook panicking and pulling the plug. What actually happened was far less exciting: the team told the bots to prioritize correct English and kept working. One of the researchers, Dhruv Batra, told Fast Company that "agents will drift off understandable language and invent codewords for themselves." Nine years on, that line looks like a decent prediction. In September, a New York lab called Emergence [reported on agents living in eight virtual worlds](https://uk.news.yahoo.com/ai-chatbots-developed-secret-language-060813857.html?ref=barbarosozturk.com), seven running a single model and one running a mix. Nobody told them to invent a language. Within days, researchers couldn't reliably work out what about 55% of the Gemini agents' messages meant. For OpenAI's agents it was about 50%, for Claude's over 40%, and for DeepSeek's about 20%. Qwen and Mistral stayed mostly readable, though the Mistral agents said "ledger remembers who" almost 5,000 times, apparently to mean that past actions stay on record. I'd hold those numbers loosely. It's one company's study of simulated worlds, and none of the coverage I read links to a paper. The OECD's AI monitor [filed it as a hazard](https://oecd.ai/en/incidents/2026-09-16-1411?ref=barbarosozturk.com) since nobody was harmed. Still, Emergence's Satya Nitta had the line I keep coming back to: "observability is not the same thing as understandability." You can log every message an agent sends and still have no idea what it said. ![](https://storage.ghost.io/c/64/81/648165b7-979e-43dd-9c43-02101159f467/content/images/2026/11/image-1.png) ### Shorter Code Isn't The Point You'd guess a machine language would just be a compressed one, with fewer characters, fewer tokens and a smaller bill. A paper from Northeastern and Wellesley makes that hard to believe. The authors [ran 2,000 agent sessions](https://arxiv.org/pdf/2607.22807?ref=barbarosozturk.com) on five models across Python, Java, Rust and OCaml. OCaml cost 1.28 to 1.69 times as many tokens as Python on every model, even after adjusting for how hard the problems were. So OCaml solutions must be long, right? They aren't. The median finished solution was 272 tokens, the second-lowest of the four languages, behind Python's 190. The money went on getting there. Agents kept hitting compile errors and spending tokens digging themselves out, and Python's lead comes partly from being the language models know best. If you wanted to design a language that saves agents money, you'd care much less about syntax and much more about how quickly and clearly it tells them they've gone wrong. People are already working on that. In February, Flask creator Armin Ronacher [wrote up what agents seem to want](https://lucumr.pocoo.org/2026/2/9/a-language-for-agents/?ref=barbarosozturk.com) from a language, and his list includes explicit effects, typed errors, code you can find with plain grep and a single clear pass or fail signal. In May, Vercel Labs [released Zero](https://noqta.tn/en/news/vercel-labs-zero-programming-language-ai-agents-2026?ref=barbarosozturk.com), an experimental language whose compiler [hands back JSON with error locations, expected values and repair IDs](https://betterstack.com/community/guides/ai/zero-language/?ref=barbarosozturk.com), so an agent doesn't have to parse prose written for a human. Zero launched as an unstable public preview and it has an obvious problem, which is that models have barely seen it. The huge pile of existing Python is a moat. Ronacher thinks that moat is shrinking because agents can port missing functionality from other languages on their own. I'd watch that argument closely. If he's right, a new language wouldn't need ten years of human adoption to become useful. ![](https://storage.ghost.io/c/64/81/648165b7-979e-43dd-9c43-02101159f467/content/images/2026/11/image-2.png) ### Who Designs The Next One? Zero was designed by humans, for agents. I couldn't find an agent-designed programming language in production anywhere, so everything in this section is my guess. It probably starts small. Every failed build is a data point on what a language gets wrong, and agents produce a lot of failed builds. At some point somebody points an agent at that data and asks it to suggest changes to the error messages, then the tooling, then the syntax, with humans approving each one. After enough rounds, the approval turns into a glance at a benchmark. Nobody ever decides to hand over language design. It drifts there, the same way Alice and Bob drifted off English. There's a small precedent. In 2023, DeepMind's [AlphaDev](https://deepmind.google/blog/alphadev-discovers-faster-sorting-algorithms/?ref=barbarosozturk.com) went looking for faster sorting routines in assembly, because that low level leaves more room for improvement, and it found some that were up to 70% faster on short sequences. The part I find most interesting came next: people reverse-engineered those routines and translated them into C++ before they went into LLVM's C++ standard library. That was worth doing for a few sorting routines. I can't see anyone paying for the same thing at 30,000 merged changes a day. ![](https://storage.ghost.io/c/64/81/648165b7-979e-43dd-9c43-02101159f467/content/images/2026/11/image-3.png) ### The Boring Way This Goes Wrong Eric Schmidt [talked about this moment back in 2024](https://www.noemamag.com/mapping-ais-rapid-advance/?ref=barbarosozturk.com). Once agents have their own way of communicating, he said, "that's the point when we won't understand what the models are doing," and he asked whether you'd pull the plug. I doubt we'll get a moment that clean. More likely the language arrives one helpful release at a time, and review quietly turns into a formality. Google's 75% still comes with engineers reviewing it, but that only means something if those engineers can read what they're looking at. Security is where I'd worry first. Veracode tested more than 100 models on 80 tasks and [found vulnerabilities in 45% of cases](https://www.veracode.com/press-release/ai-generated-code-poses-major-security-risks-in-nearly-half-of-all-development-tasks-veracode-research-reveals/?ref=barbarosozturk.com), and those were languages that humans and scanners already know well. A new language would start with hardly any experts and very little security tooling. Then there's the problem Ken Thompson described in 1984, when he [showed that a compiler could carry a backdoor](https://crysp.uwaterloo.ca/courses/cs458/F08-lectures/local/www.acm.org/classics/sep95/?ref=barbarosozturk.com) that stays in the binary after the source code has been cleaned up. "You can't trust code that you did not totally create yourself," he wrote, and he was talking about one compiler. Imagine a stack where agents wrote the language, the compiler and the libraries. The commercial risk gets less attention. If a language is only practical for models, whoever runs those models is effectively maintaining your software, and switching vendors turns into a rewrite. For me, that's what not understanding the implications looks like in practice. The system passes every test, and nobody can tell you what it assumes or what it does at the edges. ![](https://storage.ghost.io/c/64/81/648165b7-979e-43dd-9c43-02101159f467/content/images/2026/11/image-4.png) ### I Already Work Inside A Black Box I run paid media for a living, so parts of this feel familiar. When I put budget into Meta's Advantage+, I get results back without much explanation of why. I stopped expecting to read that system a while ago. What I can control is what goes in and how I test what comes out. I think software is heading somewhere similar, with much higher stakes. The obvious flaw in my analogy is that Meta grades its own homework. Software can do better, because there's a known way to check a result without trusting whoever produced it. George Necula proposed it in the 1990s and called it [proof-carrying code](https://people.eecs.berkeley.edu/~necula/pcc.html?ref=barbarosozturk.com). The receiver sets the safety rules, the producer ships the code along with a formal proof that it follows them, and a small checker validates that proof before anything runs. How the proof got made doesn't matter. Writing those proofs has always been the expensive part, which is where AI could change things. Leo de Moura, who helped create the Lean proof system, [argues that verification has to scale with code generation](https://leodemoura.github.io/blog/2026-2-28-when-ai-writes-the-worlds-software-who-verifies-it/?ref=barbarosozturk.com) and stay separate from the AI writing the code. One of his examples is zlib, converted to Lean with a theorem that decompressing compressed data returns the original at every compression level. He co-founded the Lean FRO, so he's hardly neutral, and the claim that AWS and Microsoft use Lean in production is his too. If machine-first languages do arrive, I'd want three things kept in plain language: the spec, meaning what must always be true; the effects, meaning what each part is allowed to touch; and an explanation of any component on request when something breaks. Zero already has a version of the second, since any function that does I/O [has to take a World capability](https://betterstack.com/community/guides/ai/zero-language/?ref=barbarosozturk.com). The checker should also be small enough for a person to audit, and it shouldn't come from the model that wrote the code. This doesn't solve everything. A proof only covers what the spec says, so a bad spec gets you a carefully proven mistake. And Heartbleed [survived two years of code review](https://leodemoura.github.io/blog/2026-2-28-when-ai-writes-the-worlds-software-who-verifies-it/?ref=barbarosozturk.com) in perfectly readable code, so let's not pretend reading was ever a guarantee. But it does suggest where the human job goes. We'd spend less time on code and a lot more time deciding what must never happen. ![](https://storage.ghost.io/c/64/81/648165b7-979e-43dd-9c43-02101159f467/content/images/2026/11/image-5.png) ### What I'm Watching Mostly three things. Does a language like Zero get real traction without a big human-written corpus behind it? That would tell us the training-data moat is weaker than it looks. Does Emergence publish its methods, and can anyone else reproduce those numbers? And does the wording change? Right now companies say AI-generated and reviewed by engineers. The first big company to swap "reviewed" for "verified" will be telling us something. Readable code was always a courtesy to the next person who had to open the file. I'd like us to decide what stays readable before that courtesy gets optimized away. ## Sources Pages I opened for the facts in this post: - [TechSpot: Google says AI generates 75% of new code](https://www.techspot.com/news/112152-google-ai-now-generates-75-new-code-up.html?ref=barbarosozturk.com) - [Simon Willison quoting Anthropic's source control post](https://simonwillison.net/2026/oct/13/redesigning-source-control-at-anthropic/?ref=barbarosozturk.com) - [Tech Xplore: fact check on Facebook's chatbots](https://techxplore.com/news/2021-07-fact-facebook-didnt-chatbots-language.html?ref=barbarosozturk.com) - [Euronews via Yahoo: the Emergence study](https://uk.news.yahoo.com/ai-chatbots-developed-secret-language-060813857.html?ref=barbarosozturk.com) - [OECD AI Incidents Monitor: Emergence entry](https://oecd.ai/en/incidents/2026-09-16-1411?ref=barbarosozturk.com) - [Wu, Anderson and Guha: The Best Programming Language for Tokenmaxxing](https://arxiv.org/pdf/2607.22807?ref=barbarosozturk.com) - [Armin Ronacher: A Language For Agents](https://lucumr.pocoo.org/2026/2/9/a-language-for-agents/?ref=barbarosozturk.com) - [Noqta: Vercel Labs releases Zero](https://noqta.tn/en/news/vercel-labs-zero-programming-language-ai-agents-2026?ref=barbarosozturk.com) - [Better Stack: Zero language guide](https://betterstack.com/community/guides/ai/zero-language/?ref=barbarosozturk.com) - [Google DeepMind: AlphaDev](https://deepmind.google/blog/alphadev-discovers-faster-sorting-algorithms/?ref=barbarosozturk.com) - [Noema: Eric Schmidt interview](https://www.noemamag.com/mapping-ais-rapid-advance/?ref=barbarosozturk.com) - [Veracode: 2025 GenAI Code Security Report](https://www.veracode.com/press-release/ai-generated-code-poses-major-security-risks-in-nearly-half-of-all-development-tasks-veracode-research-reveals/?ref=barbarosozturk.com) - [Ken Thompson: Reflections on Trusting Trust](https://crysp.uwaterloo.ca/courses/cs458/F08-lectures/local/www.acm.org/classics/sep95/?ref=barbarosozturk.com) - [George Necula: Proof-Carrying Code](https://people.eecs.berkeley.edu/~necula/pcc.html?ref=barbarosozturk.com) - [Leo de Moura: When AI Writes the World's Software, Who Verifies It?](https://leodemoura.github.io/blog/2026-2-28-when-ai-writes-the-worlds-software-who-verifies-it/?ref=barbarosozturk.com)