Is AI the Next Programming Abstraction Layer?

AI can interpret human intent. But we still need a precise, inspectable representation of what it thought we meant.

That gives us something we can review, compare against the requirement, test, validate, and change.

The future stack may look less like:

Human → Programmer → Code → Machine

and more like:

Human intent
    ↓
AI interpretation
    ↓
Expressive source code
    ↓
Deterministic behavior

That middle layer matters.

Programming has always moved through layers of abstraction.

We moved from binary to assembly, from assembly to higher-level languages, and then to frameworks, libraries, and platforms. Each layer let us describe more of what we wanted and less of how the machine should do it.

AI is the next step.

But AI is different from a compiler.

A compiler translates one formal language into another according to fixed rules. AI interprets natural language, and natural language is ambiguous.

Suppose I tell an AI:

A user can update their own profile, but not someone else's.

The AI can generate code for that requirement.

The important question is not whether it can produce code.

The important question is whether the code actually means what I meant.

That is where an expressive programming language becomes valuable.

The AI can read the requirement on one side and the source code on the other.

It can ask:

Does the code actually check ownership?
What happens if the user is not authenticated?
Are administrators an exception?
Can every field be changed?
Is the action logged?

In other words, AI can work in both directions.

Human intent → AI → Code
Code → AI → Explanation

Then it can compare the two.

Once we are satisfied with that interpretation, we can lock it into deterministic code.

That gives us something stable.

We can test it.

We can validate the behavior.

We can reproduce failures.

We can modify the implementation and run the tests again.

This creates a useful feedback loop:

A useful feedback loop: intent flows through AI interpretation, deterministic code, testing and validation, and modification; modification loops back to the code.

That is why better AI does not make programming languages obsolete.

It changes what we should want from them.

If AI is going to generate more of our code, then languages should focus less on saving keystrokes and more on expressing intent clearly.

We should want languages that make things explicit:

Make intent explicit

This value cannot be null.
This operation requires authorization.
This object cannot change.
This function has no side effects.
This resource belongs to this user.

The more intent we can encode directly, the less humans and AI have to infer.

AI may become the highest abstraction layer in programming.

But the layer beneath it still matters.

It is where human intent becomes precise enough to inspect, test, validate, and trust.