Rethinking Programming Languages in the Age of AI

When AI Writes the Code: Rethinking the Programming Language

Programming languages were created as an interface between human reasoning and machine execution.

That distinction is becoming less straightforward.

Humans naturally work with decimal numbers; computers operate through binary states because digital hardware is built around discrete electrical conditions. Programming languages introduced a similar abstraction: they gave humans a structured way to express logic that machines could ultimately execute.

For decades, this model remained largely unchanged:

Human → Programming Language → Compiler → Machine

Languages evolved around human needs. Python emphasized readability. Java established explicit structure and portability. Rust made ownership and memory safety part of the language itself, enabling developers to reason more precisely about how software behaves.

AI is now challenging the assumptions behind that model.

When software is increasingly generated by machines rather than written line by line by developers, the question is no longer simply how humans should communicate with computers. It becomes a more fundamental question:

What should a programming language optimize for when the primary author is an AI system?

From Human Readability to Machine Generability

Today’s AI coding agents operate largely within the existing software ecosystem: Python, JavaScript, Java, C++, Rust and the languages surrounding them.

That is partly a consequence of scale. These languages have accumulated enormous ecosystems of source code, documentation, libraries, examples and developer knowledge. AI models have been trained extensively on that material, making established languages the natural operating environment for code generation.

But widespread adoption does not necessarily make a language optimal for machine-generated software.

Experimental work is already exploring alternatives. Projects such as ilo question whether programming syntax should remain optimized around conventions that emerged primarily for human developers.

For an AI system generating millions of tokens, the economics are different. A useful language may place greater emphasis on compact representation, constrained expression, structural consistency and reduced ambiguity.

That shifts the design objective.

The relevant question is no longer simply whether code is easy for a developer to read. It is whether a system can generate, modify and reason about that code with minimal opportunity for unintended behavior.

And syntax may be the least important part of that problem.

An AI can learn where brackets and semicolons belong. The more consequential failures occur at the level of meaning: invoking an unavailable API, violating an interface contract, introducing an incompatible dependency or changing one component in a way that creates an unexpected failure elsewhere.

The central challenge, therefore, is not necessarily making programming languages easier for AI to write.

It is making incorrect software harder for AI to produce.

Verification Becomes Part of the Programming Model

This is where type systems, contracts and formal verification become strategically important.

Traditional development largely separates generation from validation: code is written first, then tested, reviewed and deployed through increasingly sophisticated controls.

AI-generated software changes the economics of that process. When an agent can produce and modify code at a scale and speed that exceeds human review capacity, verification cannot remain solely a downstream activity.

The development environment itself may need to constrain what an AI is capable of generating.

Research into type-constrained code generation illustrates this direction. Rather than allowing a model to generate arbitrary syntax and validating the result afterward, the generation process can be bounded by the types, structures and rules available within the program.

This creates a different relationship between the developer, the AI and the programming environment.

The objective is not to establish that an AI will never make a mistake. That is an unrealistic dependency.

The objective is to design systems in which mistakes are constrained, surfaced and resolved before they become system-level failures.

In AI-assisted software engineering, verification may become as important as generation.

That principle extends beyond programming languages. It points toward development environments in which permissions, interfaces, invariants, dependencies and expected behaviors are explicit parts of the software model.

Beyond Source Code

An even more fundamental question follows.

Why does an AI need to generate source code in the first place?

Source code exists partly because humans need a practical representation of software. Developers write text because text is accessible, transferable and reviewable.

The machine ultimately executes something else: a structured representation produced through parsing, compilation or interpretation.

For an AI system, the textual layer may not always be necessary.

Instead of:

AI → Source Code → Parser → Program Structure

the architecture could move toward:

AI → Program Structure

Experimental approaches such as Zerolang explore this direction by representing programs through semantic structures, including symbols, types, relationships and effects. Human-readable code can remain available, but it becomes a representation of the underlying program model rather than the sole definition of the software.

That distinction could have significant implications.

Today, the prevailing assumption is:

The source code is the program.

A future software stack could instead treat the underlying structured model as authoritative, with source code functioning as one human-facing representation of that model.

This would represent more than a new programming language. It would represent a different abstraction layer for software itself.

The Developer's Role Moves Up the Stack

As AI systems become capable of generating large volumes of software, reviewing every implementation detail becomes increasingly impractical.

The value of human involvement therefore shifts toward the boundaries, constraints and intended behavior of the system.

The critical questions become:

• What is the system intended to do?

• What must it never do?

• Which resources and data can it access?

• Which interfaces and dependencies are permitted?

• What security properties must remain invariant?

• Which behaviors require formal verification?

• What evidence is sufficient to establish that the system behaves as intended?

This is not the disappearance of software engineering. It is a shift in where engineering judgment is applied.

Developers may spend less time authoring individual instructions and more time defining system behavior, architecture, constraints and verification mechanisms.

Existing languages are unlikely to disappear as a result. Their ecosystems, tooling, libraries and accumulated knowledge represent substantial infrastructure. More likely, they will increasingly become targets within a broader AI-native development environment.

The distinction between human-facing and machine-facing representations may become more significant.

One representation can optimize for generation, transformation and verification.

Another can optimize for human understanding, governance and control.

The Emerging Software Model

The resulting architecture may look less like traditional software development and more like:

Human Intent → AI Agent → Program Model → Verification & Compilation → Machine

The important transition is not simply from human-written code to AI-generated code.

It is from code as the primary artifact to software as a structured, verifiable system of intent, behavior and constraints.

That distinction matters because the volume of software is no longer constrained only by how quickly humans can write it. As generation becomes abundant, the scarce capability shifts toward defining what software is allowed to do—and establishing, with sufficient confidence, that it does it.

The next generation of programming languages may therefore not be defined by how closely they resemble Python, Java or Rust.

They may be defined by how effectively they represent intent, constrain machine-generated behavior and make software verifiable.

And if machines increasingly write software for other machines, the long-term question is no longer whether AI will create another programming language.

It is whether human-readable source code will remain the primary artifact of software development—or become one interface into a deeper computational model.

Author: Abdurrahman Alahmar

He is a Senior Consultant at Devista with experience in software engineering. He is particularly interested in artificial intelligence, agentic AI, and engineering leadership.