AI Coding Can Require More, Not Fewer, Developers

AI is making software cheaper to build. The surprising result may be more software, broader builder access, and a developer role that shifts toward judgment.

Aayush16 September 20261 min read

When software becomes cheaper to build, the outcome is not automatically fewer developers. It can also mean far more software becomes worth building.

Part 2 of 3 - The Economic Shift
AI coding assistants and agents are changing the cost structure of software development. The useful question is no longer only, "How much coding can AI automate?" It is also: What happens to software demand when implementation becomes dramatically cheaper?

Software Has Always Had an Economic Problem

For years, software development had a simple constraint:

It was expensive to build.

Teams needed developers.

Developers needed time.

Projects competed for engineering capacity.

Many useful internal tools, niche products, workflow systems, and small automations were never built because the economics did not justify the effort.

AI is changing that.

AI coding assistants and agents can now:

write code;
generate tests;
refactor existing systems;
explain unfamiliar code;
draft migrations; and
help developers complete routine tasks faster.

That has triggered an obvious fear:

If AI can do more coding, do we need fewer developers?

There is evidence that the answer may be more complicated.

A 2026 study using LinkedIn and GitHub data found that firms adopting GitHub Copilot were associated with roughly a 3%-5% higher monthly probability of hiring software engineers, driven by entry-level hiring. New hires also showed around 5% more non-programming skills, without a decline in coding skills. [1]

That does not prove AI will always increase software-engineering employment.

But it does show that higher AI productivity and continued developer hiring can coexist.

The Jevons Paradox Helps Explain Why

There is an old economic idea that becomes unexpectedly useful here.

In the 19th century, economist William Stanley Jevons observed that making a resource more efficient to use does not always reduce total consumption.

Sometimes, the opposite happens.

When something becomes cheaper and easier to use, people discover more reasons to use it.

Applied to software, the question becomes:

What happens when the cost of building software keeps falling?

The answer may not simply be:

"Build the same amount of software with fewer developers."

It may be:

Build much more software for many more problems.

Projects that previously made no economic sense can suddenly become viable.

A custom internal dashboard.

A workflow tool for one operations team.

A niche application for one industry.

A temporary system for a campaign.

A lightweight automation for a process that previously lived in spreadsheets.

A product experiment that would once have required weeks of engineering.

As implementation becomes cheaper, the addressable market for software can expand.

Job Description Changes. Job Title Remains.

The goal of AI developer productivity should not simply be to make developers type faster.

It should be to increase what one developer can accomplish.

When implementation is difficult and expensive, the bottleneck is often:

"Who can build this?"

As AI handles more implementation work, the bottleneck begins moving toward:

"What should we build?"

That changes where developer time creates the most value.

A developer who previously spent hours implementing routine changes can increasingly spend that time on:

architecture;
product decisions;
system design;
debugging;
verification;
security;
integration;
reliability; and
difficult edge cases.

At the same time, people who could not previously participate in software creation may gain access to visual tools and AI-assisted building.

That does not eliminate the developer.

It changes the developer's leverage.

AI Growth and Developer Growth Can Coexist

AI making software cheaper does not mean companies will hire unlimited developers.

Automation can absolutely reduce the human effort required for a particular software task.

Some work will disappear.

Some teams may become smaller.

Some skills will become less valuable.

But the available evidence does not support a simple "AI adoption equals developer extinction" story.

The U.S. Bureau of Labor Statistics projects software-developer employment to grow 15.8% between 2024 and 2034, adding about 267,700 jobs over the period. [2]

Meanwhile, AI is already becoming normal inside the profession.

JetBrains' January 2026 AI Pulse survey of more than 10,000 professional developers found that 90% regularly used at least one AI tool at work for coding and development tasks, while 74% had adopted specialised AI developer tools. [3]

The job is not waiting for AI to arrive.

AI is already inside the job.

Productivity Does Not Remove the Human From the Loop

Faster implementation does not make engineering judgment irrelevant.

Research published in IEEE Software studied GitHub Copilot and Windsurf inside a fintech engineering team and found a clear productivity-validation tension.

Developers reported faster routine work.

But they still spent substantial effort on:

prompt formulation;
checking outputs;
verifying correctness; and
aligning AI-generated work with the architecture of the system. [4]

In other words:

AI can make implementation cheaper without making engineering judgment cheap.

The faster software can be generated, the more valuable it becomes to know:

whether it should exist;
whether it is correct;
whether it is secure;
whether it fits the architecture;
whether it survives edge cases; and
whether it should be deployed at all.

Six Predictions for the Developer of the Future

If AI continues making software cheaper and faster to build, the biggest change may not be whether developers exist.

It may be what developers spend their time doing.

1. Code Becomes Cheaper; Judgment Becomes More Valuable

AI will handle more syntax, boilerplate, scaffolding, and routine implementation.

That increases the relative value of:

product thinking;
architecture;
trade-offs;
engineering judgment; and
knowing when the generated answer is wrong.

2. "Software Developer" Splits Into Builders and AI Operators

Some engineers will continue working deeply in code.

Others will increasingly orchestrate:

AI agents;
visual systems;
APIs;
workflows;
data; and
deployment infrastructure.

Both can ship software.

They simply operate at different levels of abstraction.

3. Verification Becomes a First-Class Engineering Skill

When AI can generate changes in seconds, producing code is no longer the slowest step.

Testing, reviewing, validating, and understanding those changes become more important.

The developer who can reliably verify AI output may become more valuable than the developer who can merely produce more output.

4. Domain Knowledge Gains Value

If more people can generate competent software, understanding the real-world problem becomes a stronger differentiator.

Knowing:

healthcare operations;
finance;
logistics;
manufacturing;
sales;
procurement; or
compliance

can matter more when basic implementation is easier.

5. Junior Work Changes, but Juniors Still Matter

Routine tickets may shrink.

Boilerplate may disappear.

But the industry still needs the pipeline that creates senior engineers.

Junior developers may increasingly learn by:

supervising AI output;
debugging;
testing;
understanding systems;
reviewing decisions; and
building faster with assistance.

AI can reduce the cost of becoming productive without eliminating the need to become competent.

6. Developers Manage a Mixed Workforce

The developer of the future may move between:

writing code manually;
using visual tools;
configuring deterministic workflows;
delegating to AI agents; and
reviewing AI-generated work.

The skill is not "maximum automation."

It is:

Choosing the right mechanism for the right task.

More Software, Built by More People

This is the larger opportunity.

AI may reduce the cost of creating software.

If that happens, the market does not have to respond by producing the same amount of software with fewer people.

It can respond by creating software for many more problems.

That is the economic possibility behind the Jevons-paradox analogy.

And this is where FloNeo becomes relevant.

FloNeo is designed around a mixed building model:

visual controls;
direct editing;
AI-assisted building;
workflows;
databases; and
agentic assistance.

A professional developer can use automation and AI to reduce routine implementation work.

A non-developer can participate in software creation without first becoming a traditional programmer.

The two groups do not have to be enemies.

The easier software becomes to create, the more valuable experienced developers can become as:

architects;
reviewers;
integrators;
extension builders;
security-minded decision-makers; and
force multipliers for everyone else building around them.

Where LTNC Fits

FloNeo's Low Token No Code (LTNC) philosophy applies directly to developer productivity.

LTNC does not mean "use less AI at all costs."

It means:

Use AI when intelligence creates value. Use direct controls when the answer is already known.

A developer should not need an agent to:

rename a button;
move a component;
edit a known field; or
change a deterministic rule.

But AI can add real value when the task requires:

understanding ambiguity;
reasoning across several components;
proposing architecture;
planning a complex change; or
executing a bounded multi-step task.

That combination can make skilled developers faster without turning the application into an AI-controlled black box.

The Future Belongs to the Builders

The interesting future is not:

Humans or AI.

It is:

What can humans build when the cost of implementation collapses?

The data currently supports a world where AI productivity, broader software demand, new builder access, and continued developer hiring can coexist.

The developer role will change.

Some tasks will disappear.

Some skills will become less valuable.

Other skills - judgment, architecture, domain understanding, verification, integration, and AI orchestration - can become more valuable.

FloNeo's objective is not to make developers obsolete.

It is to make software creation:

cheaper;
more accessible;
more controllable; and
more leveraged.

Because if software becomes dramatically easier to build, the next question is not simply:

"How many developers do we need?"