While AI has been with us for decades, its sudden surge in popularity—thanks largely to ChatGPT and OpenAI—has sparked a steep rise in predictions that AI might eventually replace software engineers.

While everyone is entitled to their opinion, there is already data available that can provide clues about whether and when that might happen.

Before diving into this data to explore where we are heading, let’s first examine a few historical trends that can shed light on the discussion.

The Quest for Improving Developer Productivity

The quest to improve developer productivity is as old as software engineering itself.

Programming languages have evolved over time to offer more ready-to-use code blocks, enabling developers to write code faster.

For example, in the early days of Java, developers had to write even basic constructs, such as blocking queues, themselves. Today, these elements are readily available, either as part of the programming language or through external libraries.

Similarly, when Delphi (based on Pascal) was a popular language for creating user interfaces, it provided an array of easy-to-use code blocks for connecting to databases, executing queries, or building complex UI components.

The pursuit of increased developer productivity isn’t new—it’s an enduring goal that has been approached in different ways throughout history.

Why Is Improving Developer Productivity Critical?

This question might seem trivial, but it’s essential to address.

The primary driver behind improving developer productivity is the increasing size and complexity of software programs.

The average codebase size of enterprise applications has grown significantly—from thousands of lines of code in the 1980s to tens of millions today. Unless the developer productivity has also increased in parallel through all of these years, we would need an impossible number of software engineers to write these huge programs that we use nowadays.

And why has program size grown so dramatically? The main reason is the increasing capacity of underlying hardware, which allows for larger and more complex programs.

To get a perspective of that increase, in 1981, the IBM PC 5150 launched with a memory capacity of 64KB, while today, consumer laptops regularly ship with 16GB of RAM—a 250,000x increase. Similarly, hard drive storage has jumped from 5MB in 1980 (IBM 3380) to several terabytes today.

Imagine if the number of software engineers had to increase 250 000 times for the same period. As that would far exceed the total population of the planet Earth, improving the developer productivity was the only way to handle that increasing size of software programs.

Thanks to Moore’s law, software engineers no longer need to meticulously optimize their code to fit within stringent hardware constraints. Instead, they can focus on writing code faster and more efficiently.

The massive growth in hardware capabilities—including chip processing power, memory sizes, and I/O speeds—has shifted the focus from “writing code carefully to fit hardware constraints” to “writing code as quickly as possible.”

Moore’s law has fundamentally changed software engineering priorities, emphasizing speed over precision in many cases.

As hardware has enabled bigger and more complex programs, software engineers have had to continuously improve their productivity. Imagine trying to build the sophisticated programs of today using only plain old C!

AI Enters the Picture

The pursuit of improving developer productivity didn’t start with AI. It has been an ongoing effort for decades, and AI is simply the latest innovation in this long journey.

But how much is AI really helping?

A GitHub Copilot study conducted by GitHub and researchers from Microsoft found that developers who used Copilot completed tasks 55% faster than those who didn’t.
Another study by the research group OpenAI estimated that Copilot could reduce time spent on repetitive coding tasks by 60%.

This improvement is significant, and as AI continues to evolve, it’s conceivable that future iterations of AI tools could double this productivity boost.

Can AI Replace Software Engineers?

Let’s revisit the original question: Can AI replace software engineers?

To explore this, let’s consider Moore’s law as a proxy for the growth in software program size.

In the early 2000s, while I was working in the automotive industry, I remember that we had to fit an entire car’s software into just a few megabytes. A study from McKinsey noted that today’s modern vehicles run over 100 million lines of code – today, a single software update for some leading car brands can be as large as tens of gigabytes. This level of growth—from a few megabytes to gigabytes—is staggering and mirrors the rapid expansion of hardware capabilities under Moore’s law. Similar trends can be observed across other industries.

Unsurprisingly, as hardware capacity has increased, businesses have sought to maximize their utilization by developing more feature-rich and complex software.

When we compare these two numbers—the ~50% improvement in developer productivity (potentially 2x with future AI tools) and the exponential growth in program size driven by Moore’s law—the gap becomes glaringly obvious. Compare the 2-3x productivity that we expect to gain in developer productivity from AI with the 250,000x increase in RAM that we’ve witnessed since the 80s.

Even with the productivity boost from AI, the size and complexity of software programs have far outpaced improvements in developer efficiency.

The Need for Software Engineers in the AI Era

It’s also worth noting that the AI boom itself has created additional demand for software engineers. AI models need to be built, trained, and integrated into programs, requiring specialized skills that only software engineers can provide.

The World Economic Forum’s Future of Jobs Report 2023 highlighted that demand for AI and machine learning specialists is projected to grow by 37% over the next five years, with software engineering roles remaining critical in supporting this growth.

Summary

AI is undeniably a powerful tool for enhancing developer productivity, but I really doubt that it will replace software engineers entirely.

The growth in program size and complexity, coupled with the demand for AI-specific expertise, will more likely result that software engineers will remain critical to the industry for the foreseeable future.