Every generation thinks the next breakthrough will make programmers obsolete.
Assembly programmers watched compilers take over machine-level instructions.
Developers watched frameworks replace thousands of lines of custom code.
Infrastructure engineers watched cloud platforms automate the provisioning and management of servers.
Now, programmers are watching artificial intelligence generate code from plain English.
And once again, we're hearing the same prediction:
"Programming is going away."
But what if we've got it exactly backward?
What if AI isn't the end of programming, but simply the latest chapter in a story that has been unfolding since the first computers?
Here's my thesis:
The history of programming is the history of transferring complexity from humans to machines. Every generation programs at a higher level of abstraction, solving bigger problems while delegating more of the implementation.
AI isn't breaking that pattern.
It's accelerating it.
And the most interesting question isn't whether prompt engineering is programming. It's what comes after programming intent.
Look at how programming has evolved.
1. Assembly Language — Tell the machine exactly what to do.
Programmers worked with registers, memory addresses, and processor instructions. Assembly replaced binary machine code with symbols humans could understand.
The programmer controlled the execution. The machine followed instructions.
2. High-Level Languages — Describe the algorithm.
FORTRAN, COBOL, C, and their successors let developers express computations without specifying individual machine instructions.
Compilers handled the translation.
The programmer focused on logic, not registers.
3. Structured and Object-Oriented Programming — Model the problem.
Functions, modules, objects, and interfaces made it possible to organize increasingly complex systems.
Developers began thinking in terms of customers, transactions, and business processes rather than individual instructions.
The programmer focused on architecture, not just algorithms.
4. Libraries and Frameworks — Assemble capabilities.
Why build your own networking stack, database driver, or authentication system when you can use an existing one?
Developers began combining sophisticated, reusable capabilities instead of implementing everything themselves.
The programmer focused on integration, not reinvention.
5. Cloud Computing — Declare what you need.
Physical servers gave way to infrastructure as code, containers, and managed services.
Instead of configuring every machine, developers specified resources, services, and operating requirements.
The programmer focused on infrastructure outcomes, not hardware administration.
6. Low-Code and No-Code — Describe the workflow.
Visual tools allowed users to construct applications through configurations, rules, and workflows.
The programmer—or increasingly, the business user—focused on processes rather than syntax.
7. LLMs and Prompt Engineering — Express the intent.
Now we can describe a desired software capability in natural language:
"Build an application that securely processes customer orders, handles failures, and includes automated tests."
An LLM can propose the architecture, generate code, select libraries, and assist with implementation.
The programmer increasingly focuses on the desired behavior, not every implementation step.
Notice the pattern?
We haven't stopped programming. We've continuously changed what we program.
| Era | What humans increasingly program |
|---|---|
| Assembly | Instructions |
| High-level languages | Algorithms |
| Structured / object-oriented | Models |
| Libraries / frameworks | Capabilities |
| Cloud computing | Infrastructure requirements |
| Low-code / no-code | Workflows |
| LLMs | Intent |
| What's next? | Objectives and outcomes |
These aren't complete replacements for one another. They are overlapping layers that build on decades of accumulated capability.
But the direction is unmistakable.
Every abstraction moves the programmer one step closer to the actual problem and one step farther from the mechanics of implementation.
That's not the disappearance of programming.
That's its evolution.
I think we're debating the wrong thing.
Some argue that writing a prompt isn't programming because natural language isn't deterministic.
Fair point.
A compiler translates a formal language according to defined rules. An LLM generates responses probabilistically and can make mistakes.
But consider what programming has always been about.
We express instructions or requirements to a computing system so that it produces useful behavior.
The tools change. The languages change. The level of detail changes.
The fundamental objective doesn't.
Prompt engineering involves defining goals, supplying context, establishing constraints, and specifying acceptable results.
That's not merely chatting with a computer.
That's directing a computational system.
Of course, generating an answer and producing reliable software are two very different things.
Which brings us to the next major shift.
It's AI Taking Responsibility for More of the Engineering Process.
Generating code is impressive.
But writing code is only part of software engineering.
Software must compile, integrate, run, meet requirements, handle exceptions, remain secure, and perform reliably.
The next generation of AI systems is moving beyond code generation toward coordinating entire engineering workflows.
Imagine specifying an objective and having a system:
That's a fundamentally different relationship between humans and computers.
The programmer is no longer responsible for explicitly coordinating every step.
Instead, the programmer establishes the objective, constraints, and evidence required for success.
The next abstraction isn't just AI-generated code. It's AI-orchestrated engineering.
And that brings us to a question I find even more interesting.
If we've spent decades moving from specifying how a computer should work toward specifying what it should do, what happens when we no longer need to specify the solution at all?
Today, we might tell an AI:
"Build an application to improve customer onboarding."
Tomorrow, we might say:
"Reduce customer onboarding time by 50% without compromising security, compliance, or customer satisfaction."
Notice the difference.
The first statement describes a solution.
The second describes an objective.
What if an intelligent system could investigate the process, identify bottlenecks, evaluate alternatives, implement improvements, measure results, and continuously refine its approach?
We wouldn't necessarily be programming an application.
We'd be programming an outcome.
That is a much more profound shift.
Consider the evolution:
The further we move up the abstraction stack, the closer we get to human objectives.
And the more important human judgment becomes.
Because defining an outcome introduces questions that cannot simply be delegated away.
What should we optimize?
What tradeoffs are acceptable?
How do we know the outcome is genuinely beneficial?
Who is accountable when the system gets it wrong?
The challenge shifts from telling the machine how to perform the work to determining what work is worth doing.
Higher abstraction does not eliminate complexity.
It relocates it.
Compilers didn't eliminate the need to understand algorithms.
Frameworks didn't eliminate the need for software architecture.
Cloud platforms didn't eliminate reliability and security engineering.
And AI won't eliminate the need for technical judgment.
In fact, the more sophisticated our systems become, the more important it is to understand their limitations.
A system that produces plausible code isn't necessarily producing correct code.
A system that completes a task isn't necessarily achieving the right objective.
And a system that optimizes a metric isn't necessarily delivering the intended benefit.
Abstraction transfers implementation work to machines. It doesn't transfer ultimate accountability away from humans.
The strongest engineers will understand when to trust the abstraction, when to verify it, and when to look beneath it.
I don't believe the future belongs exclusively to people who can write the most code.
Increasingly, it may belong to people who can define the most important problems, architect effective solutions, establish meaningful constraints, and verify that the outcomes are correct.
The traditional programming skills won't suddenly become irrelevant.
They will become part of a broader engineering discipline.
The role will evolve.
Just as it always has.
And that's the opportunity.
Not the elimination of programmers.
The expansion of what a programmer can accomplish.
We've moved from machine instructions to algorithms.
From algorithms to components.
From components to platforms and workflows.
From workflows to intent.
And perhaps next, from intent to objectives and outcomes.
Every transition has allowed humans to solve more ambitious problems while delegating more of the implementation to machines.
AI is not the end of this progression.
It's the latest step—and possibly the beginning of its most dramatic acceleration.
So instead of asking whether AI will replace programmers, perhaps we should ask a better question:
If computers can increasingly figure out how to build what we want, are we ready to become better at deciding what is worth building in the first place?
Because the future of programming may not be defined by how well we communicate with machines, but by how wisely we decide what machines should accomplish.