Artificial intelligence is transforming software development at remarkable speed.
AI coding assistants can generate code, explain complex functions, detect bugs, write tests, refactor applications, and increasingly perform entire development tasks with limited human intervention. As these systems become more capable, a legitimate concern has emerged:
If AI makes programming dramatically more efficient, will we need fewer programmers?
At first glance, the answer seems obvious.
If a developer assisted by AI can produce the same amount of software in half the time, companies should need fewer developers to produce the same output.
But there is an economic paradox that challenges this assumption.
It is known as the Jevons Paradox.
And it may offer an unexpected perspective on the future of software engineering: when technology makes a resource dramatically more efficient and cheaper to use, demand for that resource can increase rather than decrease.
Applied to AI and programming, this raises a fascinating possibility:
AI may eliminate some programming jobs while simultaneously creating demand for more programmers.
What Is the Jevons Paradox?
The Jevons Paradox was described by British economist William Stanley Jevons in the 19th century.
Jevons observed that technological improvements making coal use more efficient did not necessarily reduce overall coal consumption. Greater efficiency made coal-powered technologies cheaper and more economically attractive, which encouraged their wider adoption.
The important idea is that efficiency changes economics.
When something becomes cheaper, society tends to consume more of it.
The same principle can potentially be applied to software development.
What Happens When Programming Becomes Cheaper?
Consider a simple example.
Imagine that a software developer traditionally needs 10 hours to build a particular feature.
With increasingly capable AI coding tools, the same feature might eventually require only 2 hours of human involvement.
From the perspective of a single project, this appears to reduce the need for developers by 80%.
But what happens to the other 8 hours?
The company may use the productivity gains to build additional features.
Instead of developing 10 features, it might develop 50.
Instead of maintaining one internal application, it might build five.
Instead of automating only its most expensive processes, it might automate hundreds of smaller ones.
Instead of commissioning software only when the expected return is very high, companies may begin building software for problems that were previously not worth solving.
This is where the Jevons Paradox enters the picture.
AI Could Make Software Abundant
For decades, software development has been constrained by the cost of creating software.
Ideas are everywhere.
Software engineers are not.
A company may have hundreds of potential digital products, internal tools, automations, integrations, dashboards, and data applications it could build.
But most of them never get built because development is expensive.
There simply aren't enough engineering resources to pursue every idea.
AI changes this equation.
If AI dramatically reduces the cost of producing software, the economic threshold for building software also falls.
Projects that previously made no financial sense can suddenly become viable.
This could lead to a dramatic expansion in the amount of software produced.
And that creates an important distinction:
AI can reduce the amount of human labor required per software product while increasing the number of software products that companies want to build.
The first effect reduces demand for labor.
The second can increase it.
The question is which effect will be larger.
The Paradox of the AI Programmer
This creates a potential paradox for software developers.
Suppose one programmer using AI becomes five times more productive.
A company could theoretically replace five programmers with one.
That sounds like a straightforward reduction in employment.
But imagine that the productivity improvement also makes software five times cheaper to produce.
The company may respond by increasing its software development ambitions.
It could now afford to build applications that previously required budgets it could not justify.
Other companies may do the same.
Entire industries that previously used relatively little custom software could begin developing specialized digital tools.
The result could be a much larger software economy.
In simplified terms:
Higher developer productivity → Lower software costs → More software projects → Greater demand for software development
This does not guarantee that employment will increase.
But it demonstrates why higher productivity does not automatically mean fewer workers.
The Industrial Revolution Provides a Useful Analogy
Technology has repeatedly replaced human labor in specific tasks while simultaneously expanding the industries in which those tasks were performed.
The important question is not simply whether technology can perform a task.
It is whether reducing the cost of that task causes society to demand significantly more of the resulting product or service.
AI coding tools may be doing exactly that with software.
Programming has historically been expensive enough that organizations had to prioritize what they built.
AI could weaken that constraint.
If software becomes substantially cheaper, organizations may stop asking:
"Do we really need to build this?"
and start asking:
"Why wouldn't we build this?"
That change in mindset could have profound consequences for the labor market.
The Software We Don't Build Today
One of the biggest variables in predicting AI's impact on programmer employment is something that is difficult to measure:
the software that does not currently exist.
Economic statistics typically measure existing jobs and existing products.
But technological progress can create entirely new demand.
Before websites became widespread, there was little demand for web developers.
Before smartphones, there was no large-scale market for mobile app developers.
Before cloud computing, many of today's cloud engineering roles did not exist.
The same principle could apply to AI-assisted software development.
If the cost of creating software falls dramatically, companies may discover entirely new uses for software.
There could be millions of small applications that become economically viable only because AI makes development inexpensive.
That additional demand could require human developers—even if each individual developer becomes far more productive.
AI May Change What Programmers Do
There is another important factor.
AI does not necessarily have to replace the programmer as a profession to replace many programming tasks.
The role itself may evolve.
Developers could spend less time manually writing repetitive code and more time on:
- System architecture
- Product design
- Security
- Requirements analysis
- Reviewing AI-generated code
- Testing and validation
- Data engineering
- Integration
- Performance optimization
- Managing AI coding agents
- Understanding business requirements
- Making complex technical decisions
In this scenario, programming becomes less about typing code and more about engineering software systems.
The distinction is important.
If AI can produce code cheaply, the scarce resource may no longer be the ability to write syntax.
It may be the ability to understand what should be built, why it should be built, and how all the pieces should work together.
The Demand for Software Could Explode
Imagine a world in which building a custom application costs a fraction of what it costs today.
A small business could have its own inventory system, customer portal, analytics platform, scheduling software, AI assistant, and internal automation tools.
A manufacturer could develop specialized software for individual production lines.
A logistics company could build custom optimization systems for different warehouses.
A retailer could create highly specialized tools for individual stores.
A professional services company could automate hundreds of small workflows that currently depend on spreadsheets and manual processes.
Much of this software is not built today—not because there is no potential value, but because the cost of development is too high relative to the expected benefit.
Lowering that cost could unlock enormous latent demand.
This is perhaps the strongest argument for applying the Jevons Paradox to software engineering.
But Will Programmer Employment Actually Increase?
This is where caution is necessary.
The Jevons Paradox does not mean that AI will inevitably create more programming jobs.
There are several possible outcomes.
Scenario 1: Substitution dominates
AI becomes so capable that the amount of additional software created is insufficient to compensate for the reduction in human labor required.
In this scenario, programmer employment falls.
Scenario 2: Expansion dominates
AI dramatically lowers development costs, triggering a huge increase in software production.
The additional demand for software becomes large enough to create more jobs than AI eliminates.
In this scenario, programmer employment could increase.
Scenario 3: Transformation dominates
The number of traditional programming jobs declines, but demand grows for a broader category of software professionals.
The industry becomes smaller in terms of manual coding but larger in terms of architecture, AI supervision, security, product engineering, systems integration, and other technical disciplines.
This third scenario may ultimately be the most interesting.
The Real Question Is Not "Will AI Replace Programmers?"
The question may be poorly framed.
A better question is:
How much will the cost of producing software fall, and how much additional demand will that create?
If AI reduces software development costs by 90%, but the market for software becomes 100 times larger, the total amount of human labor required could still increase.
Conversely, if software demand grows only modestly while AI eliminates most of the labor involved in development, employment could decline significantly.
The outcome depends on the relationship between productivity growth and demand growth.
That is precisely what makes the Jevons Paradox so relevant.
A New Era of Software Development
AI could therefore produce a counterintuitive outcome.
The technology may initially appear to threaten programmers because it automates programming tasks.
But the same automation could make software so inexpensive that businesses begin demanding vastly more of it.
This could create a new economic environment in which software becomes ubiquitous.
Programming would no longer be reserved for projects with sufficiently large budgets to justify a dedicated engineering team.
Software could become a commodity that organizations create continuously, for increasingly narrow and specialized purposes.
And when the cost of building something falls, the number of things worth building tends to increase.
The Programmers Who Thrive May Be Different
This does not mean every programmer will benefit equally.
AI is likely to put pressure on developers whose work consists largely of repetitive, predictable coding tasks.
At the same time, developers who understand systems, business problems, architecture, security, data, and complex technical trade-offs may become more valuable.
The most successful developers may not necessarily be those who can write the most code.
They may be those who can direct the creation of software effectively.
In that sense, AI could shift programming from a production activity toward a higher-level engineering and problem-solving discipline.
The Jevons Paradox and the Future of Work
The broader lesson extends beyond programmers.
Technological progress frequently changes the relationship between productivity, prices, demand, and employment.
When a technology makes something cheaper, there are two opposing forces.
The first is substitution:
We need fewer workers to produce the same amount.
The second is expansion:
Because the product is cheaper, we want to produce and consume much more of it.
The future of employment depends on the balance between these two forces.
AI is now putting this dynamic to the test in one of the world's most digital industries.
Conclusion: AI May Not Kill Programming—It May Make It Ubiquitous
The rise of AI coding tools undoubtedly creates a serious challenge for the traditional software development profession.
Some programming tasks will disappear.
Some roles will shrink.
Some developers will be able to produce what previously required entire teams.
But this is only one side of the equation.
If AI makes software dramatically cheaper to produce, businesses may respond by creating vastly more software. New applications, new products, new automations, and entirely new categories of digital services could become economically viable.
That is the potential Jevons Paradox of AI.
The technology that makes programmers more productive may also make software more abundant.
And when software becomes cheaper, the demand for software may increase.
The ultimate consequence could therefore be more nuanced than simple replacement:
AI may reduce the amount of human effort required to build each piece of software while increasing the total amount of software the economy wants to build.
The future of programming may not be defined by how much code AI can write.
It may be defined by how much new software humanity decides is worth creating once the cost of creating it approaches zero.
And if history is any guide, making something dramatically more efficient does not always mean we use less of it.
Sometimes, we simply find a lot more reasons to use it.
