Will AI Replace Software Engineers?

Are software engineers really on their way out? Let's discuss.

What Can History Tell Us?

People have been predicting "the end of programmers" for decades.

These people often misunderstand what good programmers actually do.

In reality, most tech shifts ended up creating more jobs, not less.

When frameworks like React abstracted low-level work, demand for websites and web developers exploded.

Other examples:

Spreadsheets didn't kill accountants. They killed busywork and created new roles in financial modeling and analysis.
CAD didn't replace architects. It made design better and faster, leading to growth in construction, aerospace, and product design.
Unity and Unreal didn't eliminate game developers. They democratized game creation, spawning countless new studios and projects.

Automation Is Good for the Software Industry

Effective automation does two things:

Lowers the barrier to creation, triggering an industry boom.
Removes grunt work, allowing humans to tackle creative or complex tasks.

Efficiency gains don't kill demand, they unlock it.

Effects of automation seen across industries suggest AI will boost the volume of software we ship.

As Sam Altman (interview), Thomas Dohmke (article), folks at Mckinsey (article), and countless others point out, the world wants way more software, whether it realizes it or not. And AI will deliver it.

If AI lets 6 developers do the work of 10, sure, that's fewer people per project.

But those efficiency gains will fuel more projects, more companies, and more software around the world.

Lean teams are already driving some of the fastest-growing startups in tech.

Limitations of AI

If you, as a practicing developer, try to use AI to accomplish your tasks, you'll make the following observations:

AI is great for highly scoped tasks, but struggles with complex problems that require sustained reasoning or nuanced logic.
Developers don't trust AI beyond surface-level suggestions when it comes to complex tasks.
AI tools are good pattern imitators, but they can't write novel algorithms or solutions for problems they have not seen before.
1/ Can Large Language Models (LLMs) truly reason? Or are they just sophisticated pattern matchers? In our latest preprint, we explore this key question through a large-scale study of both open-source like Llama, Phi, Gemma, and Mistral and leading closed models, including the… pic.twitter.com/yli5q3fKIT
— Mehrdad Farajtabar (@MFarajtabar) October 10, 2024

Research by Apple's AI scientists found no evidence of formal reasoning in language models.
Just when you start to trust AI, it confidently gives you code that's buggy, unsafe, or simply wrong.
Things get risky when you are not actively reviewing AI generated code.
AI tools work with a limited context window which often misses the big picture. It overlooks design trade-offs, architecture, maintainability, and the broader business context.
The above graph comes from a recent study which depicts how LLM performance falls apart as problems get bigger. Microsoft Azure CTO concedes that AI fails to handle large projects. Raiinmaker CTO talks about AI's struggles with architecture and system design in this post.
If you're not deliberate, you'll waste more time trying to force AI to do the job than just doing it yourself.

Overall, the current quality of AI-generated code is only as good as the engineer prompting and reviewing it. In the hands of an experienced developer, AI becomes a powerful assistant that boosts productivity.

In the hands of someone without strong programming foundations and hygiene, programming using AI is a slippery slope, and gets counter-productive real fast.

Honest reflections from coding with AI so far as a non-engineer:

It can get you 70% of the way there, but that last 30% is frustrating. It keeps taking one step forward and two steps backward with new bugs, issues, etc.

If I knew how the code worked I could probably fix it…
— Peter Yang (@petergyang) December 1, 2024

Vibes are NOT all you need.

Gergely Orosz (The Pragmatic Engineer) and Addy Osmani (Engineering Lead at Google) have published an excellent deep dive into this dynamic.

AI is like a junior developer that never sleeps, but needs a senior to review everything.

The Future of Programming With AI

Today, most developers rely on AI as an assistant in some form.

97% of developers in a GitHub survey said they've used AI tools at work.

Tech leaders are also echoing the shift:

Sundar Pichai says "well over 30%" of Google's code is now written by AI.
Andy Jassy shared that Amazon saved 4500 developer-years thanks to AI.
Satya Nadella revealed that 20–30% of their code is now AI-generated.

Multiple studies have confirmed the productivity gains that have accompanied this change. For example, GitHub research shows a 55% increase in developer productivity with Copilot.

We're nearing a point where a single software engineer could be 10x more productive. Sam Altman believes that could happen well before 2027.

However, the extent of automation varies across different software engineering tasks. AI is mostly taking over basic, well-defined, and repetitive tasks.

Task	2022	2023	2024	2025
Boilerplate Code	Copilot handled routine patterns. Output needed reviews.	GPT-4 improved accuracy, handled multi-step prompts.	Integrated into IDEs, models better at context. Editing needed.	Nearly fully automated. Reliable for standard scaffolding.
Debugging	Mostly manual. GPT-3 lacked context.	GPT-4 could explain errors. Fixed basic bugs, but often hallucinated.	AI helped trace bugs across files. Good at syntax and logic issues.	Fast, helpful with widely known errors. Weak on runtime errors.
Code Review	Lint + basic CI. AI played no real role.	Surface-level AI checks.	Helpful for small fixes, security flags.	Bots catch common issues. Still miss the intent sometimes.
Test Generation	Mostly unit test boilerplate.	GPT-4 wrote decent coverage but missed edge cases.	Context-aware suggestions. Still needs vetting.	Solid for simple logic with vetting. Complex paths tricky.
Knowledge Help	GPT-3 was hit-or-miss. Devs stuck to StackOverflow.	GPT-4 better at docs, concepts, live examples.	Became the first stop over StackOverflow.	Default dev assistant. Still needs validation on edge cases.
Architecture Design	No use	GPT-4 gave decent outlines. Often over-engineered.	AI offered diagrams, nudged best practices.	AI aids brainstorming but not design. Lacks project context.
Codebase Navigation	Couldn't help.	Could fetch answers from a single file.	Larger models emerged. Much better traceability.	AI can handle repos which are not too complex.
PR Writing / Docs	Manual effort. AI tools limited.	AI started summarizing and suggesting drafts.	PR titles, changelogs, READMEs auto-drafted.	Fully automated writing. Still lacks product tone.
Prototyping / MVPs	You start from scratch. MVPs took days.	Scaffolded fast with AI. Hours instead of days.	UI + logic + docs co-built with AI.	Solo developer = small team. Works well.
Product Thinking	No AI help.	AI summarized docs, explained user stories.	Helpful for early validation. Shallow instincts.	Still a human craft. AI lacks product sense.
Solving Novel Problems	You build from scratch.	GPT-4 gives bad ideas.	AI can suggest useful patterns.	Still your edge. AI breaks on unfamiliarity.
Code Performance	Manual tuning.	AI could explain perf concepts	AI suggests low-hanging wins.	Still on you to push real performance gains.
Security Awareness	Mostly handled post-hoc by AppSec.	AI can warn about OWASP-style issues.	Integrated into review and IDEs. Flags problems early.	Catches basic issues. Dangerous to trust entirely.

YoY progress across common developer tasks

But even with this growth rate, we are far, far away from 100% automation where you can use AI to build complex software without touching code.

Until we have human-level reasoning in machines — which is not likely in the near future — programmers are not going anywhere.

People who don't want to learn how to program can always find a reason why not to. This time it's AI, last time it was that tech was over because the Internet Bubble burst, the time before that it was that all the programming jobs were going to be outsourced to India.
— Paul Graham (@paulg) April 15, 2024

Be honest, segmentation faults scare you more than AI.

Sam Altman, Addy Osmani, Linus Torvalds, Yann LeCun, Sundar Pichai, Satya Nadella, Arvind Krishna, Bill Gates, Grady Booch, Jeff Dean, Thomas Dohmke, Tim O'Reilly, Paul Graham, Sabrina Farmer, and other thought leaders in tech (who are not selling an agenda or chasing investment rounds 👀) agree on this.

Become a Good Software Engineer

It's important to be honest here.

If your day-to-day work primarily involves simple CRUD apps, API integrations, static sites, scripting, writing boilerplate code, quality assurance, or routine bug fixes, you are at high risk.

AI is already good at that stuff, and it's only a matter of time before it takes over these tasks completely.

Don't be a code monkey.

Our recommendation would be to become a better software engineer, someone who reviews AI's work and tackles the problems it can't.

Here are some concrete steps:

Deepen your computer science fundamentals.
Work on complex programming challenges and projects.
Practice system design and architecture.
Get good at reviewing code, knowing when it's wrong, and fixing it.
Get good at defining requirements based on product and business context.
Learn how to ship real software with good performance, scalability, reliability, observability, security, and cost effectiveness.
Start using AI today. (read next section)

Before AI, there was already a noticeable gap between those who treated software as a craft and those who didn't — whether in terms of pay, opportunities, or respect. AI is rapidly and aggressively expanding this gap.

Software engineers who master their craft will end up with more interesting work, greater leverage, and stronger job security than ever before.

A lot of software can be built quickly now but it is becoming a lost art to actually make it self-serve and consumer-quality.

You must sand down all the edges and fix the P2 bugs, instead of only focus on the demo paths.

This year, personal software will force its return.
— Garry Tan (@garrytan) December 2, 2024

Hone the craft of building high-quality software experiences.

Start using AI today

AI won't replace software engineers. But engineers with strong programming fundamentals who also use AI effectively will 100% replace those who don't.

Here are 11 ways you should start using AI in your workflow today:

Autocomplete and grammar hints: Use AI as a co-pilot which autocompletes your code and spots typos before you do.
AI in IDEs can fill in syntax, boilerplate, and even entire functions based on context.
Project setup: Let AI handle the initial setup, standard patterns, and basic code. You review and shape it into something useful.
This saves time and tedious work, letting you jump straight into feature development.
Debugging assistant: Take help from AI to diagnose and fix bugs. It will catch something right away, or it will hallucinate. Either way, it's a fast second pair of eyes.
Always ask it to take the first stab at debugging.
Knowledge on demand: Ask it to explain concepts, help when you're stuck, and answer questions about your repo.
Great for junior developers and onboarding new teammates.
Test generation: Get it to write unit tests. You'll still need to review them and cover missing edge cases.
AI can draft straightforward tests you can build on.
Code review: Use AI to scan PRs and highlight style issues, logic bugs, security flaws, and more.
CodeRabbit and Sourcegraph Cody are surprisingly good at context-aware reviews.
Rubber ducking: Brainstorm with AI. It can give new ideas and raise points you might have missed.
The rubber duck talks back now.
Bootstrapping: Use AI to turn designs and concepts into rough MVPs in hours instead of weeks.
This helps you reach the first round of user feedback quickly.
Refactoring: Use AI for refactoring, but always run tests since it can sometimes break code.
It's time to finally modernize that legacy code.
Error Handling: Tasks like error handling can be verbose, and AI takes away the grunt work.
AI is really good at implementing timeouts, retries, fallbacks, and graceful degradation.
Documentation: Use AI to document your code in real time.
Improve clarity, maintainability, and collaboration without any extra effort.