Every generation claims programmers are about to be replaced. COBOL, 4GLs, visual tools, no-code, and now AI. Each time, the interface gets easier, but complexity returns. Programmers don’t disappear. The bar just rises.
We’ve been trying to replace programmers for over sixty years.
And every single time, people think the same thing:
This is it.
This is the breakthrough.
This is the moment we don’t need programmers anymore.
Right now, it’s AI.
Before that, it was no-code.
Before that, low-code.
Before that, visual programming tools.
Before that, fourth-generation languages.
And before all of that?
COBOL.
COBOL: The First Attempt
Back in 1959, COBOL was created with a very specific goal.
Not to help programmers.
To replace them.
The idea was simple.
If code looked like English…
Then businesspeople could write software themselves.
You’d see lines like:
“ADD HOURS-WORKED TO TOTAL-HOURS.”
“IF TOTAL-HOURS IS GREATER THAN 40, PERFORM OVERTIME-CALCULATION.”
The thinking was…
if you understand the business, you can write the system.
No need for technical specialists.
But that’s not what happened.
COBOL didn’t eliminate programmers.
It created a new kind of programmer.
Because understanding business rules…
is not the same thing as building working systems.
Those systems grew.
They became massive.
They became interconnected.
They became fragile under change.
And today?
COBOL developers are still in demand.
Not because COBOL is great.
But because the systems became too complex to replace.
4GLs: Describe What You Want
Then came fourth-generation languages.
The promise shifted.
Now it was:
Don’t tell the computer how to do something.
Just tell it what you want.
SQL is a perfect example.
“Give me all customers with a balance over a thousand.”
Simple. Clean. Declarative.
And it worked… to a point.
But the second you needed real-world behavior…
Edge cases.
Custom logic.
Integrations.
Performance tuning.
You were right back to needing programmers.
Visual Programming: Drag and Drop
Then we tried visual programming.
Drag and drop.
Boxes and arrows.
No syntax. No code.
The idea was that people think visually, so let’s build software visually.
But those systems didn’t scale.
They turned into visual spaghetti.
Harder to debug.
Harder to maintain.
Harder to understand.
The complexity didn’t disappear.
It just changed shape.
No-Code: It Works… Until It Doesn’t
Then came no-code and low-code.
And this one felt real.
Because for the first time, non-developers could actually build things.
Internal tools.
Simple apps.
Automations.
And for that, it’s great.
But then something happens.
The product gets traction.
And reality shows up.
Now you need:
Custom workflows.
External integrations.
Better performance.
Evolving data models.
And suddenly the conversation shifts.
“We need a real backend.”
“We hit platform limits.”
“We need something more flexible.”
No-code doesn’t replace programmers.
It delays needing them.
The Pattern
And that’s the pattern.
Every time.
Because all of these attempts are based on the same assumption.
That programming is just translating ideas into syntax.
That’s not what programming is.
Programming is dealing with ambiguity.
It’s managing complexity.
It’s handling all the weird, messy, real-world edge cases that nobody thought about upfront.
Take something that sounds simple.
“Track deliveries.”
Okay.
Now add reality.
Partial deliveries.
Missing items.
Late shipments.
Wrong locations.
Human error.
Conflicting schedules.
Now ask:
What should the system do?
That’s the real work.
No tool removes that.
AI: The Latest Attempt
And now we’re at AI.
The newest, most convincing attempt yet.
“Just describe your app.”
“Generate your system.”
“You don’t need developers anymore.”
And to be clear…
AI is powerful.
It’s very good at generating code.
It speeds things up.
It removes a lot of the mechanical effort.
But it doesn’t own the system.
It doesn’t understand long-term consequences.
It doesn’t manage evolving requirements.
It doesn’t take responsibility when things break.
It gives you output.
It does not give you ownership.
So what’s actually changing?
Before, programmers wrote everything.
Now, they guide systems.
They validate outputs.
They make architectural decisions.
They decide what matters and what doesn’t.
The role isn’t going away.
It’s getting harder.
Because now you’re not just writing code.
You’re responsible for systems that are being generated, modified, and accelerated faster than ever.
And if you zoom out, the pattern is obvious.
Every attempt follows the same cycle.
A new tool abstracts complexity.
People think the problem is solved.
Real-world edge cases appear.
Complexity comes back.
Skilled people are needed again.
The Reality
Here’s the truth.
Software is not hard because of code.
It’s hard because of reality.
COBOL didn’t replace programmers.
No-code didn’t replace programmers.
AI won’t replace programmers.
But every wave does change the job.
And every wave raises the bar.
Because at the end of the day:
Tools don’t remove complexity.
They just move it.
And software?
Software is not a project.
It’s a commitment.
