A look at how Jevons’ 19th-century paradox is playing out in modern code — where every leap in efficiency creates more developers, not fewer.

---

The Efficiency Illusion

Every few decades, a new tool arrives promising to make coding easier. And every time, the same question resurfaces: 

If the machine can code, what happens to the coder?

The fear isn’t new. It echoed through the arrival of assembly languages in the 1950s, integrated development environments in the ’90s, and cloud automation in the 2010s. Each shift came with predictions of redundancy. Each one ended up creating more developers than it displaced.

The British economist William Stanley Jevons noticed a similar pattern 160 years ago. As steam engines became more efficient, coal consumption didn’t fall. It skyrocketed. Lower costs expanded the field of possibility. 

His observation, now known as Jevons Paradox, described a law of progress:

AI is doing the same to code. Tools like Copilot, Cursor, and Gemini Code Assist are drawing millions more people into the act of creation. Stack Overflow’s 2024 Developer Survey found that over 80% of developers use AI assistance regularly, while GitHub data shows a new developer joins the platform every second. India alone is on track to surpass 57 million developers by 2030.

For decades, every leap in computing has followed the same rhythm: a new language emerges, the barrier to entry drops, and the developer population swells. 

In his AI Day 2025 keynote, our CEO Vivek Ravishankar traced that lineage from Assembly to C++, from Python to the AI-assist era and showed how each layer multiplied the developer class:

AI isn’t breaking that pattern. It’s amplifying it. And with that acceleration comes a redefinition of what it means to be a developer.

A decade ago, software demanded fluency in syntax and tooling. Now, AI abstracts away much of that mechanical layer. The ceiling is rising toward orchestration, system design, and taste, while the floor is dropping low enough for millions of new entrants to build through natural language.

The result is both democratization and divergence: everyone can build, but excellence will stand out more sharply than ever. The same paradox that once governed coal and steam now defines code.

 

To truly see the scale of what’s happening, we can plot the history of development itself — a curve that reveals how every new abstraction expands the total number of people who build.

 

The Jevons Curve of Code

The Jevons Curve of Code shows how every leap in abstraction has expanded and not contracted the developer population. Each phase of progress reduced friction, invited new participants, and redefined what counted as programming.

The Jevons Curve captures this relationship between efficiency and expansion. It’s a rising curve where productivity and participation grow together. Think of it like this:

Each productivity leap removed a layer of complexity and pulled new builders in. As the cost of writing software dropped, the surface area of what could be built (startups, internal tools, niche applications, entire new markets) grew too.

Each new generation of tools shifted the center of gravity: from specialists to generalists, from infrastructure to innovation. 

The IDE brought code to desktop developers; open source and cloud made global collaboration routine. Now, AI-assisted coding platforms like GitHub Copilot and Replit Ghostwriter are doing the same for intelligent systems. They’re literally turning English into execution. 

The next curve might not be about writing code at all, but about composing systems where humans define intent and AI handles nearly all implementation. AI is simply the next step in such a sequence. 

Each technological leap widens the circle of who could build. And at no moment in history has that expansion been more visible than right now, as development itself becomes democratized.

Democratization and Differentiation

Analyst forecasts reinforce this trend: the global low-code/no-code development market is projected to exceed $180 billion by 2030, growing at more than 25% CAGR from 2024. 

Creation is shifting from specialists to a mass participation model — where software becomes a universal language. 

And so, the ‘billion builders’ trajectory isn’t a metaphor; it’s a macroeconomic signal that the act of building is being unbundled from formal engineering.

AI collapses barriers faster than any prior tool. A marketing analyst can query a database in natural language, a designer can prototype an app through conversation, and a student can deploy an API without writing a single line of code. 

Entire companies now operate with a mix of professional and “citizen” developers — Notion’s ecosystem of custom templates, Canva’s AI-driven design macros, and countless Zapier automations illustrate how creation now happens at the edge. 

Gartner projects that citizen developers will soon outnumber professionals four to one inside large enterprises, while IDC expects that by 2032, over 70% of business applications will be built or extended by nontraditional developers.

This democratization doesn’t make professionals obsolete; it magnifies their importance. Casual creators expand the frontier of ideas, but professional developers provide the scaffolding (security, observability, architecture, governance) that keeps the new abundance from collapsing under its own weight. 

Jevons Paradox applies here as well: each simplification of creation multiplies complexity elsewhere. More builders mean more systems to secure, more data to manage, and more opportunities to differentiate through taste, rigor, and care. 

In short, AI expands access, but it also increases responsibility. The Jevons curve bends upward once again. 

But access is only part of the story. Beneath the flood of new builders lies another transformation: how AI is quietly rewiring the very engine of software productivity.

 

AI as the New Productivity Engine

Before diving into AI’s impact, it’s worth noting that earlier productivity leaps — from the introduction of integrated development environments (which studies suggest improved developer throughput by nearly 25%) to cloud-native toolchains (which cut deployment times by more than half) — have also historically raised expectations, not lowered demand.

The evidence is mounting. In a controlled GitHub study, developers using Copilot finished tasks 55% faster than those coding unaided. McKinsey estimates AI could raise overall software-engineering productivity by 20 to 45%. Bain finds the real leverage comes when AI spans the entire software-development lifecycle (requirements, design, testing, deployment, and maintenance), not just code generation.

Yet the macro result isn’t usually smaller teams. It’s bigger ambitions:

• Projects that once needed months can now be prototyped in days, so organizations tackle more of them
• Startups that couldn’t afford a ten-person backend team can now field two developers and an AI copilot. 
• Enterprises are redeploying saved developer hours into new initiatives (internal tools, automation, AI-integrated features, etc.)

The same phenomenon Jevons saw in the coal era repeats: efficiency lowers marginal cost, which raises total demand.

Atlassian’s internal data shows engineers spend only 16% of their week actually coding. The rest goes to coordination, debugging, testing, deployment, and documentation — areas now ripe for AI augmentation. 

The tools don’t eliminate those steps; they multiply the number of cycles teams can run.

As the tools accelerate, so do expectations. Efficiency at scale demands a new kind of engineer, fluent in both systems and intelligence. That’s where the next generation of developers emerges.

 

The Emergence of the Next-Gen Developer

According to LinkedIn’s 2025 Emerging Jobs Report, demand for AI-fluent software engineers has surged nearly 60% year-over-year, and Glassdoor data shows compensation premiums of 15–25% for developers proficient in AI frameworks and orchestration tools. The emergence of this new breed of engineer reflects a profound shift in leverage: the ability to command AI as an extension of one’s own reasoning. 

They’re less defined by syntax mastery and more by their ability to shape intelligent systems and blend software design, AI/data fluency, and critical thinking into a new discipline.

Efficiency changes the job description. Yesterday’s developer wrote code; today’s developer orchestrates intelligence. Across companies, a new archetype is forming: the Next-Gen Developer.

 

They’re defined by four traits:

1. Grounded in fundamentals. Data structures, architecture, and systems thinking still matter; AI amplifies poor logic as easily as good logic.
2. AI-fluent across the SDLC. Uses intelligent agents in requirement gathering, design, testing, deployment, and maintenance.
3. Conversant in AI primitives. Prompt engineering, retrieval-augmented generation, vector databases, multi-component protocols, orchestration frameworks.
4. Builds with care and taste. Understands business context, ethical boundaries, user experience, and long-term maintainability.

The shift mirrors a larger truth: 

Programming — translating human intent into syntax — is no longer the bottleneck. Software development — shipping reliable, scalable, loved products — still is. 

Next-gen developers operate at that higher layer, turning models, APIs, and agents into production systems that work in the real world. Their craft combines technical rigor with systems intuition: understanding not only how to make models run, but when and why to deploy them. 

The rise of the next-gen developer and the democratization we’ve been talking about widens the entry ramp but also raises the ceiling. With AI handling the routine, mastery shifts to areas that remain stubbornly human: 

• Judgment → knowing when to trust a model’s output and when to verify;
• Abstraction → framing problems so AI can reason effectively; 
• Evaluation → building metrics for quality, bias, latency, and cost; and 
• Taste → the intuition that separates functional software from something users love.

In the coming years, these engineers will define what ‘good software’ even means. They’ll balance velocity, reliability, and intelligence in the same way past generations balanced front-end and back-end concerns. And they’re be invaluable because of the leverage they bring to the table across these domains.

If the role of the developer is being rewritten, so too must be the organizations that hire, evaluate, and enable them.

 

The Organizational Reckoning

Recent Gartner research indicates that over 40% of large enterprises have already updated their technical hiring assessments to include AI-assisted and system design components, and McKinsey projects that number will surpass 70% by 2027. This signals a decisive shift toward evaluating the orchestration and reasoning skills that define the AI-era developer.

For CTOs and engineering leaders, the paradox carries a warning: the tools are racing ahead of the teams using them. Hiring practices built for a pre-AI era (syntax quizzes, algorithm puzzles, whiteboard questions) no longer measure what matters. The next-gen developer needs assessment on orchestration, collaboration, and AI-assisted problem solving.

Most of the organizations we work with are re-architecting their talent pipelines accordingly: attract engineers fluent in AI across the SDLC; assess practical skills in collaborative IDEs with AI assist enabled; upskill existing teams in prompt design, evaluation frameworks, and AI governance; and mobilize talent where automation multiplies impact instead of duplicating it.

The companies that get this right will see Jevons Paradox as a competitive advantage — each efficiency gain becomes a new market, not a workforce reduction.

History suggests that this expansion is only beginning. Each era of technological efficiency has unleashed a larger wave of creativity than the last, and AI is no exception.

 

What Happens Next

When Jevons first described his paradox in 1865, coal consumption in England had nearly quadrupled within decades of efficiency gains — steam engines using half the coal still led to twice the output. That historical echo provides a perfect bridge to today’s software economy.

Jevons never saw a GPU cluster or a language model, but his insight echoes through the data centers of 2025. As software creation becomes cheaper, we build more of it. As more people build, the demand for mastery, safety, and taste increases. The resource we’re consuming isn’t coal; it’s human creativity.

And creativity, it turns out, obeys the same law of abundance. When the cost of creation falls, the appetite for creation is infinite.

If the paradox holds and more people become developers because of AI’s efficiency, three shifts will define the decade. 

1. Software everywhere. The number of active codebases, micro-apps, and internal tools will multiply. 
2. Developers as conductors. The center of gravity moves from code authorship to system orchestration and governance. 
3. Skills as currency. The market will value fluency in AI concepts, architectural rigor, and taste.

AI will almost certainly not end software engineering. It will mark the moment it becomes a universal language spoken by billions, refined by professionals, and orchestrated by the next generation of developers. Jevons saw it in coal. We’ll see it in code.