“Will AI replace software engineers?”
It’s probably the most common question I’ve heard over the past 2-3 years.
Every conference discusses it.
Every LinkedIn influencer has an opinion.
Every student entering computer science wonders if they’re choosing the wrong career.
For a long time, I thought I had to pick a side.
Either AI would replace developers.
Or it wouldn’t.
The more I worked with AI in production systems, the more I realized both answers miss the point.
They’re answering the wrong question.
Five Years Ago, Engineers Were Paid to Write Code.
Today, many engineers are paid to decide whether AI wrote the right code.
That sounds like a subtle shift.
It changes everything.
Because once writing code stops being the bottleneck, something else becomes valuable.
Judgement.
I Didn’t Notice AI Getting Better.
I Noticed My Job Changing.
When I first started building software, writing code was the work.
Open an IDE.
Think.
Write.
Debug.
Repeat.
Today, I still write code.
Just... significantly less of it.
Instead, my days revolve around questions like:
How should this system be architected?
Is this data model scalable?
Does this workflow actually solve the customer’s problem?
Should this process even exist?
Is the AI output reliable enough to trust?
A few months ago, I was working on a healthcare feature store for genomic research.
At first glance, it sounded like a software engineering problem. Convert data. Build pipelines. Write code.
But as the project evolved, I realized something unexpected.
The Python wasn’t the difficult part.
The difficult part was deciding how researchers should query the data, how datasets should be versioned, what architecture would still work as the data grew, and how the system could support future machine learning workloads without being redesigned again.
Those weren’t coding problems. They were judgement problems.
AI could help me write pieces of the implementation. It couldn’t decide what the implementation should optimize for.
This realization has stayed with me & ironically, the keyboard has become a smaller part of engineering. The decisions have become a much larger part.
That shift happened quietly.
Most people haven’t realized how significant it is.
AI Isn’t Replacing Engineers.
It’s Replacing Engineering Tasks.
There’s an important distinction.
AI can already:
generate boilerplate code
write SQL queries
draft documentation
create unit tests
explain unfamiliar codebases
translate between programming languages
summarize logs
suggest bug fixes
That’s impressive.
But notice something.
None of those activities define software engineering.
They’re pieces of it.
The actual job is much broader.
Someone still has to understand what problem is worth solving.
Someone still decides whether an AI-generated solution is secure, scalable, compliant, and actually useful.
Someone still owns the consequences when production breaks at 2 AM.
That responsibility hasn’t disappeared.
If anything, it’s becoming more valuable.
This shift is already being observed across the industry. For example, Microsoft's Work Trend Index reports that knowledge workers are increasingly using AI to offload routine tasks so they can focus on higher-value decision-making and creative work.
Coding Is Slowly Becoming a Commodity.
That sounds harsh.
But history suggests it’s exactly what happens to every technology that matures.
There was a time when knowing HTML alone could get you hired.
Then it became expected.
The same happened with Git.
Cloud.
Containers.
Soon, AI-assisted coding will feel just as ordinary.
Writing Python won’t disappear.
It just won’t be enough.
Ten years from now, saying “I know Python” might sound a little like saying “I know Excel.”
Useful?
Absolutely.
A competitive advantage?
Probably not.
The calculator didn’t eliminate mathematicians.
It eliminated the value of doing arithmetic by hand.
Spreadsheets didn’t eliminate accountants.
They eliminated manual bookkeeping as the core skill.
In both cases, the work didn’t disappear.
It moved upward.
AI is becoming the calculator and the spreadsheet of software engineering.
I Think the Future Belongs to Domain Experts.
This is the prediction I’m most confident about.
Imagine two engineers.
The first knows every Python trick imaginable.
The second understands oncology research, cloud architecture, healthcare regulations, and uses AI effectively to build solutions.
Who is harder to replace?
I’d argue it’s the second.
AI can learn syntax.
It cannot instantly learn years of industry context.
It doesn’t attend customer meetings.
It doesn’t navigate organizational politics.
It doesn’t understand why one seemingly “incorrect” business rule has existed for fifteen years because changing it would disrupt thousands of users.
This aligns with what organizations like Anthropic and OpenAI have repeatedly emphasized in their discussions on AI-assisted work: the value shifts from producing output to directing systems, evaluating results, and making high-level decisions.
Technology becomes cheaper.
Context becomes more expensive.
The Biggest Risk Isn’t AI.
It’s Staying Comfortable.
When people say they’re worried about AI replacing developers, I think what they often mean is this:
“What if the work I’m doing today becomes automated?”
That’s a valid concern.
Because much of it will.
Routine implementation.
Boilerplate APIs.
Simple dashboards.
Data cleaning scripts.
Standard CRUD applications.
AI is becoming remarkably good at repetitive engineering work.
The solution isn’t to compete with AI.
The solution is to move toward problems AI still struggles with.
Architecture.
Systems thinking.
Product decisions.
Communication.
Leadership.
Domain expertise.
Those aren’t just “soft skills.”
They’re becoming technical advantages.
My Five Predictions for 2036
I could be wrong.
Technology has a habit of surprising everyone.
But if I had to make five bets today, they’d be these:
1. AI will write most routine code.
Developers will spend far more time reviewing than writing.
2. Engineering teams will become smaller.
Not because software matters less.
Because each engineer will accomplish dramatically more.
3. Domain expertise will become more valuable than language expertise.
Knowing healthcare, finance, robotics, or biotech will matter more than mastering another framework.
4. Junior engineering roles will evolve.
Companies won’t stop hiring graduates. But they’ll expect them to contribute to larger problems much earlier.
5. The best engineers won’t be the fastest coders.
They’ll be the best decision-makers.
So... Should Students Still Learn to Code?
Absolutely. But don’t stop there.
Learn systems.
Learn cloud.
Learn databases.
Learn how businesses operate.
Learn how to explain complex ideas.
Learn how to ask good questions.
Most importantly...
Learn how to work alongside AI instead of competing against it.
Every major technological shift creates fear.
It also creates opportunity.
The people who thrive usually aren’t the ones resisting change.
They’re the ones learning where new value is being created.
What I’m Betting My Career On
I’m not betting that AI will replace software engineers.
I’m betting that software engineers who understand systems, industries, and people will become dramatically more valuable.
The more I work, the more I believe code isn’t the scarce resource anymore.
Good judgement is.
Knowing what to build.
Knowing why it matters.
Knowing when an AI-generated solution is elegant! and when it’s dangerously wrong.
That’s becoming the real job.
The Question I’m Asking Myself
I don’t think software engineering is disappearing.
I think it’s evolving into something far more interesting.
For decades, our value came from turning ideas into code.
Maybe, over the next decade, our value will come from turning ambiguity into clarity while AI handles much of the implementation.
If that happens, perhaps the title “software engineer” won’t fully describe what we do anymore.
Maybe we’ll simply become problem solvers with exceptionally powerful tools.
And maybe...
that’s what software engineering was meant to become all along.
What are you betting on?
I’d genuinely love to hear your perspectives.