Every few decades, software development undergoes a shift so significant that it changes what we optimise for. We moved from assembly language to high-level languages because humans needed more expressive abstractions. We moved from procedural programming to object-oriented and functional paradigms because software systems became too large for individual developers to reason about. Today, we are entering another transition. For the first time, software is no longer written exclusively by humans. The Assumption We've Never Questioned. Almost every convention in modern software engineering exists for one reason: Humans are the primary readers and writers of code. That's why we use:
Descriptive variable names
Small functions
Classes
Modules
Namespaces
Comments
Design patterns
SOLID principles
Clean Architecture
These aren't requirements of computers. They're tools for reducing human cognitive load. A compiler doesn't care whether a variable is named customerAccountBalance or x42. Neither does the runtime. But what about AI?
AI Doesn't Read Code Like We Do
Large Language Models don't "read" code in the way humans do. They don't scan folders. They don't navigate IDEs. They don't memorise APIs. Instead, they process tokens, statistical relationships, and attention across context windows. That raises an interesting question: What if the way we've structured software for decades is actively suboptimal for AI?
Existing Research Is Starting to Ask Similar Questions
This isn't an entirely new direction. Recent work such as "Beyond Human-Readable: Rethinking Software Engineering Conventions for the Agentic Development Era" argues that many long-standing software engineering practices should be reconsidered as AI agents become first-class software developers. Researchers have also explored whether models can reason directly about compiler intermediate representations such as LLVM IR, rather than conventional source code, suggesting that human-readable programming languages may not be the only or even the best representation for machine reasoning. Earlier work like Neural Code Comprehension (inst2vec) showed that machine learning models can learn meaningful program semantics from compiler-level representations instead of traditional source code. Meanwhile, several experimental "AI-first" programming languages have started appearing, asking what a language designed primarily for LLMs might look like. These are all fascinating directions. But I think they're asking the wrong question.
The Question Isn't "What Programming Language Should AI Use?"
The bigger question is: What should software itself look like if humans are no longer the primary consumers of implementation code? Programming languages are only one layer. Software engineering also includes decisions about:
project structure
module boundaries
naming
dependency management
abstraction
documentation
architecture
Almost all of these evolved around human limitations. What if AI has completely different ones?
Some Thought Experiments
Do Variables Need Human Names?
Humans benefit from: calculateMonthlyInterest() because it communicates intent. But would an LLM perform just as well or perhaps even better with something like: FN_FINANCE_INTEREST_0047 or even stable semantic identifiers? Natural language is ambiguous. Structured identifiers don't have to be.
Do Files Matter?
Humans navigate directories because we can't hold entire systems in working memory. An AI doesn't "browse" a repository. It searches across it. Perhaps folders and modules remain useful. Perhaps they're unnecessary. We don't actually know.
Are Classes Human Abstractions?
Inheritance, encapsulation, and object hierarchies make complex systems easier for people to reason about. Would AI prefer entirely different structures? Perhaps dependency graphs. Perhaps immutable dataflow. Perhaps something we haven't invented yet.
Should Source Code Even Be the Canonical Representation?
This is the idea I find most interesting. Instead of treating source code as the source of truth, imagine an AI-native representation that stores:
semantic relationships
dependency graphs
stable identifiers
metadata
architecture
Human-readable code becomes a generated view. Much like compilers already generate machine code from higher-level representations.
How Could We Test This?
Training two foundation models from scratch would be prohibitively expensive. Fortunately, that isn't necessary. Instead, we could take an existing codebase and automatically transform it into multiple semantically equivalent representations:
Conventional source code
Identifier-based representations
Flattened project structures
Graph-oriented representations
AI-native intermediate formats
We could then evaluate the same LLM across tasks such as:
Bug fixing
Feature implementation
Refactoring
Architecture reasoning
Dependency analysis
If one representation consistently improves performance, we'd have evidence that software structure not just model capability matters.
The Real Opportunity
Most current research asks: How do we make programming languages more AI-friendly? I think the more interesting question is: How do we redesign software engineering itself for machine cognition? Those are very different problems. One changes syntax. The other questions seventy years of accumulated assumptions about how software should be organised.
Maybe Human-Readable Code Is Just Another Abstraction
For decades, we've assumed that source code is the product. Perhaps, in the future, source code becomes just another interface. Humans express intent. AI operates on an internal representation optimised for reasoning. Compilers generate executables. Human-readable code is simply one of many possible views. That may sound radical today. Then again, so did high-level programming languages once.
References & Further Reading
Beyond Human-Readable: Rethinking Software Engineering Conventions for the Agentic Development Era (2026): https://arxiv.org/abs/2604.07502
LLVM IR Meets LLMs: Advancing LLVM Code Comprehension with Intermediate Representation Instructions (ICML 2025): https://proceedings.mlr.press/v267/jiang25p.html
Neural Code Comprehension: A Learnable Representation of Code Semantics (inst2vec): https://arxiv.org/abs/1806.07336