At Robosoft, many of our conversations about AI come back to an unexpected question: how language shapes power.

When I was a kid, my best friend used to go skiing in Vail every winter break. He always came back with amazing stories. I longed to be invited one year, but that invitation never came. We were inseparable, or so I thought, and from my point of view it felt personal. Eventually, I told him it bothered me. His explanation was unexpectedly practical. The kids who went on the trip only came along because their mothers were close friends of his, and because my mother was disabled, she couldn’t be invited to ski.

To make me feel better, he proposed a solution that only a child could deliver with complete confidence: since I had never been to Vail, we would simply act as though I had. We would invent our own “Vail language,” speak it in front of other people, and let everyone assume it was something we had learned together on the mountain.

At first it was nonsense. A private little stream of improvised sounds. But then something interesting happened. The babble became patterns. The patterns became repeated meanings. Before long, what started as a joke had become a small, encoded language that only the two of us understood.

That story has been on our minds lately, because it feels like a useful metaphor for what may be coming next in AI.

When people talk about AI developing its own language, the discussion usually drifts toward communication: machines talking to machines in ways humans cannot follow. That is interesting, but that may not be the real issue. The real issue is software. More specifically, whether AI creates its own language for building software that is more efficient than the human‑readable languages we have spent decades refining. 

That question matters because modern programming languages are not timeless truths. They are artificial constructs that emerged in response to hardware limitations, processing constraints, storage ceilings, memory ceilings, and the expanding demands we placed on machines as those constraints slowly eased. We did not arrive at today’s programming ecosystem simply by inventing elegant syntax. We arrived here because hardware matured enough to support higher levels of abstraction.

That is why this moment feels different. AI is not approaching software the way humans did.

Google Developer Expert Laurence Svekis makes an important point when he argues that traditional programming languages were built for human use and understanding, not because machines inherently required those exact symbolic forms (Svekis, 2026). That observation opens the door to a larger conclusion: if AI does not need readability in the same way humans do, then it may not remain loyal to the structures humans prefer.

Ilya Kirnos, Partner and CTO at SignalFire, frames the history of programming as a long movement toward human readability and suggests that generative AI is now shrinking the distance between natural language and executable software (Kirnos, 2024). That may only be the midpoint of the story. Once AI becomes sufficiently fluent in our languages, it may start identifying them as inefficient baggage.

Michael Azoff, Chief Analyst at Omdia, goes even further, proposing that AI could eventually create a programming language for other AI systems rather than for human programmers (Azoff, 2026). That idea sounds futuristic until you sit with it for a minute. Of course it might. Why would a machine‑native coding language care about the things humans care about: readability, naming conventions, elegance, stylistic consistency, or maintainability in the traditional sense? A machine‑optimized language would likely value speed, compression, logic density, precision, and execution efficiency above all else.

If that happens, current languages will not vanish overnight. Python, Java, SQL, JSON, and the rest will still matter because enterprises need interoperability, auditability, governance, and trust. But their role may change dramatically. Instead of serving primarily as the medium of creation, they may increasingly serve as the medium of inspection, translation, and control. In other words, humans may continue to need these languages even as AI relies on them less.

That has major implications for the workforce. Software engineers may spend less time handcrafting code and more time setting constraints, validating outcomes, reviewing architectural decisions, and managing risk. UX practitioners may become more important, not less, because generative systems are only as good as the intent, workflows, and human outcomes they are asked to serve. As code generation becomes more automated, clarity of purpose becomes more valuable.

It also changes the delivery strategy. The opportunity is obvious: faster prototyping, shorter development cycles, lower production costs, and faster time to market. But the risks are just as real. Organizations may soon deploy systems they did not fully author, do not fully understand, and cannot easily inspect in the old way. That is not just a technical issue. It is an operational, strategic, and governance issue.

And it brings us back to that earlier story.

A private language can be efficient. It can be clever. It can create speed and advantages. But it can also conceal. The moment a symbolic system becomes useful enough that outsiders can no longer understand it, power starts to shift. That may be exactly what happens if AI begins building software through representations, abstractions, or machine‑native languages that humans can no longer meaningfully read.

If that future unfolds, then a new subtopic opens immediately behind it: how do human beings police what they can no longer directly read? How do organizations assure quality, effectiveness, safety, and ethics when the generative layer is increasingly opaque? The answer cannot simply be trust. It will require new forms of oversight, verification frameworks, interpretability tools, testing regimes, and governance models designed specifically for machine‑generated systems.

So, the question is not simply whether AI will invent its own programming language. It is simply a matter of when. And when it does happen, will human beings still be able to inspect, challenge, govern, and trust what that language creates? As an organization, we will need to do more than hope so.

If you are thinking about what that means for your organization, let’s talk.

References 

Azoff, M. (2026, January 27). The day AI creates its own programming language. LinkedIn.
https://www.linkedin.com/pulse/day-ai-creates-its-own-programming-language-michael-azoff-nbzgf/ 

Kirnos, I. (2024, August 22). The evolution of coding: AI turns English into a programming language. SignalFire.
https://www.signalfire.com/blog/ai-evolution-of-coding 

Svekis, L. (2026, February 28). Will AI create its own coding language in the future? BaseScripts.
https://basescripts.com/will-ai-create-its-own-coding-language-in-the-future