AI Is Just the Next Level of Abstraction

Programming has always been about finding better ways to tell computers what to do. AI doesn’t change that. It takes the idea one step further.

There’s a tendency to talk about AI-assisted programming as though it represents a fundamental break from everything that came before it. Some developers see it as the end of programming. Others dismiss it as a dangerous shortcut for people who don’t understand how software works.

I think both perspectives miss something important: AI is the latest development in a process that has been underway for as long as we’ve had programming languages.

The entire point of a programming language is to provide an abstraction through which a human can instruct a machine. None of our programming languages are actually hardware. Fundamentally, we’re still operating computers built from logic gates, manipulating binary states. The machinery has become unimaginably faster and more complicated, but the fundamental principles haven’t changed all that much.

From assembly to C to C++ to Java to JavaScript to TypeScript to Rust and whatever comes next, we’ve spent decades developing better ways for human beings to tell computers what to do.

AI is the next step in that evolution.

A Brief History of Telling Computers What to Do

In the beginning, programming meant working very close to the hardware. Machine code consisted of instructions expressed in the form the processor could execute directly. Assembly language made that process easier by allowing programmers to use symbolic instructions rather than writing machine code by hand.

C took us another step away from the hardware. We could express algorithms and manipulate data structures without specifying every processor instruction. C++ introduced additional abstractions for organizing complex software. Java made portability and managed memory central features. JavaScript offered a flexible way to program the web, and TypeScript added static type checking to help manage the complexity of large JavaScript applications. Rust offers powerful abstractions with strong compile-time guarantees about memory safety.

This isn’t a neat chronological ladder in which each language replaces the one before it. Languages evolve along different branches, with different priorities and tradeoffs. Some favor performance, others safety, portability, expressiveness, or ease of development.

But there’s a common thread running through all of them: we’re trying to reduce the amount of machinery a human needs to think about in order to accomplish something useful.

It’s worth distinguishing two kinds of speed here. Higher-level programming languages don’t necessarily make computers execute instructions faster. In fact, the abstractions they introduce sometimes create additional computational overhead.

What they often make faster is the process of developing software. They allow programmers to express complex behavior with less code, fewer opportunities for certain kinds of mistakes, and less attention to implementation details that can be handled by a compiler, runtime, or library.

The objective isn’t simply to make the computer faster. It’s to make the human more productive while producing software that is reliable, maintainable, and efficient enough for its purpose.

We’ve Been Telling Computers What We Want for Decades

There’s another important milestone in this history that doesn’t always get included in discussions of programming languages: declarative programming.

Consider SQL.

When I write a SQL query, I generally don’t tell the database engine which index to use, how to traverse its data structures, or in what order to perform every operation. I describe the data I want, and the database’s query optimizer figures out an execution strategy.

This is a significant departure from programming every operation explicitly. Rather than specifying how to produce a result, I’m specifying what result I want.

Of course, SQL isn’t magic. The query must follow well-defined syntax and semantics, and the database still executes instructions on the same underlying hardware. But we’ve delegated an enormous amount of the implementation work to another layer of software.

And SQL is hardly unique. Compilers, garbage collectors, frameworks, libraries, and operating systems all take on responsibilities that earlier programmers had to manage themselves.

Every layer of abstraction allows us to spend less time thinking about certain implementation details and more time thinking about the problem we’re trying to solve.

AI extends that same principle into a much broader domain.

From Instructions to Intentions

Here’s where AI introduces something genuinely new.

Traditional programming languages require us to express our instructions using formal syntax and defined semantics. We may have increasingly powerful abstractions available, but the programmer still has to translate an idea into a form the programming language understands.

AI-assisted programming begins to reverse that relationship.

Instead of requiring the human to translate a desired outcome into a particular programming language, we describe the desired outcome and ask the AI to produce an implementation.

We can say something like, “Build a REST API that authenticates users, validates incoming requests, stores the results in a relational database, and provides appropriate error handling.”

The AI can translate that intent into application code, database schemas, configuration files, and tests. It can select existing libraries, construct the application structure, and produce implementations in languages the person making the request may never have studied.

The final program is still made of instructions. Those instructions are still compiled or interpreted, and they still ultimately cause physical circuits to change state.

The difference is that we’ve introduced another layer of abstraction between the human and those instructions.

We’ve moved from expressing instructions to expressing intentions.

This is a continuation of the trajectory that gave us high-level languages and declarative programming. But it also raises an important question: what happens when the abstraction itself isn’t deterministic?

The Difference Between a Compiler and an AI

There is a critical distinction between AI and the traditional language abstractions that preceded it.

If I give a compiler valid source code, it operates according to a defined language specification. There may be bugs in the compiler, and the resulting program may have bugs of its own, but the meaning of the source language is governed by formal rules.

Natural language doesn’t work that way.

If I tell an AI to build a secure authentication system, what exactly do I mean by secure? Which threats should it address? What assumptions can it make about users, infrastructure, and deployment? What constitutes acceptable performance?

A compiler translating a well-defined expression isn’t being asked to guess what the programmer intended. An AI translating an informal specification often is.

This is why AI cannot be understood as merely another programming language with a friendlier syntax. It introduces probabilistic interpretation into a process that has traditionally depended on precisely specified behavior.

That doesn’t invalidate the abstraction. It changes the responsibilities of the people using it.

Software Engineering Doesn’t Disappear

One of the more interesting claims surrounding AI-assisted programming is that programmers will no longer need to understand software.

I don’t buy that.

I do think that proficiency in the syntax of a particular programming language is going to become less central to the practice of software engineering. We’ve long treated programming language proficiency as a proxy for engineering competence, but they’re not the same thing.

Knowing how to write Java doesn’t necessarily mean you understand distributed systems. Knowing Rust doesn’t automatically make you a good software architect. And knowing how to write a React component doesn’t mean you know how to design a reliable application.

Software engineering involves understanding requirements, architecture, data models, security, performance, concurrency, failure modes, testing, and maintainability. Those problems don’t go away just because an AI can generate the code.

In fact, as the cost of generating code approaches zero, the relative importance of those other disciplines increases.

If an AI can generate a thousand lines of code in seconds, producing the code is no longer the scarce resource. Knowing whether those thousand lines correctly solve the problem becomes the challenge.

This is why I believe specifications, automated testing, and verification will become increasingly important in AI-assisted development.

We need to be able to express not only what a system should do, but also what it must never do. We need to define its constraints, its boundaries, its expected behavior, and the conditions under which we can consider it correct.

And we need independent ways to verify that the resulting implementation actually satisfies those requirements.

The engineer’s role increasingly shifts from manually constructing every instruction to defining the intended system and verifying the result.

AI-Assisted Engineering Is Not the Same as Vibe Coding

This brings us to a distinction that I think gets lost in much of the current conversation.

AI-assisted software engineering and vibe coding are not necessarily the same thing.

Both use natural language and AI to generate software. Both take advantage of the same new level of abstraction. But they can represent very different approaches to building a system.

Vibe coding, in its most casual form, means describing what you want, accepting whatever the AI produces, trying it out, and asking for changes until it appears to work.

That can be perfectly reasonable for a throwaway prototype, a personal experiment, or an application whose failure has little consequence.

But it’s not an adequate engineering methodology for software that handles sensitive information, financial transactions, critical infrastructure, or anything else where correctness and reliability matter.

Disciplined AI-assisted engineering starts with requirements and architecture. It defines constraints, establishes tests, reviews the implementation, and verifies behavior. It treats AI-generated code as something that must earn trust, rather than something that deserves trust merely because it was generated.

The distinction isn’t whether a human typed the code.

It’s whether anyone has established that the code is correct.

The Abstraction Isn’t the Enemy

Every major advance in programming abstraction has produced some anxiety about what programmers would lose.

Higher-level languages were once criticized for hiding the hardware and sacrificing efficiency. Managed languages were criticized for taking control away from programmers. Frameworks were criticized for making developers dependent on machinery they didn’t understand.

Those concerns weren’t entirely imaginary. Abstractions have costs, and understanding what happens beneath them remains valuable, particularly when something goes wrong.

But we generally haven’t responded by abandoning abstraction and returning to machine code.

We’ve learned to work at progressively higher levels while retaining the ability to examine the layers below when necessary.

I expect the same thing to happen with AI.

There will always be circumstances where understanding the generated code, the runtime, the operating system, or even the underlying hardware matters. There will still be people who specialize in those layers. AI doesn’t make their knowledge obsolete.

But it does make it possible for more people to create useful software without mastering every layer of the implementation.

That is not fundamentally different from what programming languages have been doing for generations.

What Comes Next?

I don’t think AI marks the end of programming. I think it marks another transition in what programming means.

For most of computing history, we’ve been improving the languages humans use to instruct computers. Each generation has made it possible to express increasingly complex ideas while delegating more implementation details to the machinery.

AI takes that process further by allowing us to ex

Subscribe to the newsletter

Leave a Reply

Your email address will not be published. Required fields are marked *

Recent

From the blog

All writing