AI was supposed to replace the developer.
What if a developer using AI turns out to be cheaper?

For the past few years, the story around AI and programming has been fairly simple.

First: AI will help developers.

Then: AI will write most of the code.

And in the more dramatic headlines: AI will simply replace developers.

But set aside the demo, benchmark and price per million tokens, and a much less glamorous question remains:

what does it cost to complete the whole task correctly?

Code does not just need generating. Someone must understand what we are building, make architectural decisions, review the result, test it, integrate it with the rest of the system and take responsibility.

That is where the proportions become more interesting than “humans versus AI”.

AI really can speed up programming

In a controlled experiment with GitHub Copilot, developers using the tool completed a particular task on average 55.8% faster than the group without it.

That is a strong result. Remember, though, that it concerned one specific, well-defined task — writing an HTTP server in JavaScript — rather than the entire software-development process.

In practice, AI is well suited to taking on tasks such as:

• boilerplate and repetitive code;
• first drafts of tests;
• documentation;
• log and error analysis;
• repetitive changes;
• research into documentation and libraries.

In these tasks, the machine’s advantage can be brutally simple: it generates faster, does not get bored and can work on several things at once.

Then AI slows developers down by 19%

In 2025, METR studied experienced open-source developers working in repositories they knew well.

Participants expected to work faster. Instead, under the experiment’s conditions, using the AI tools available at the time increased average task completion time by around 19%.

The authors themselves stress that this concerned a particular environment, particular people and tools from early 2025. It is not proof that “AI slows programming down”.

But it illustrates something else very well:

generating code faster is not the same as completing a project faster.

Someone has to review AI-generated code

In its report on AI-assisted software development, DORA describes AI as an amplifier of the organisation. It can amplify good processes, but also bad ones.

Producing code faster does not in itself guarantee faster, more reliable software delivery.

Once the model prepares a change, someone still has to answer some boring questions:

• does this solve the right problem?
• does it break something else?
• is it secure?
• does it fit the architecture?
• can it be maintained later?
• does the user need it at all?

That is work. It is often much more expensive than generating the code itself.

The trust problem has a price too

The Stack Overflow Developer Survey 2025 reveals an interesting paradox. AI tools are widely used, but trust in their accuracy is clearly limited.

46% of developers said they distrusted the accuracy of AI answers, while 33% said they trusted them. Only around 3% reported very high trust.

The most commonly reported frustration was solutions that are “almost right, but not quite”.

Anyone who has worked with this for a while knows the economic model:

AI does “an hour’s work” in five minutes. A person then spends forty minutes finding out why the final 10% does not work.

The cost of automation starts looking rather different from the token price alone.

Tokens can get cheaper while tasks get more expensive

Gartner calls this mechanism the Inference Paradox.

Unit model costs may fall, but agentic workflows perform more steps, use more models, analyse more context and consume more inference.

Gartner forecasts that inference cost per agentic workflow could increase more than fivefold by 2028.

So rather than asking:

“What does a million tokens cost?”

it increasingly makes sense to ask:

“What does completing the task correctly cost?”

Half a billion dollars on Claude in a month?

Here, the quality of the data matters.

In June 2026, Axios reported an AI consultant’s account of a client who supposedly spent around half a billion dollars on Claude in a single month after failing to impose suitable usage limits.

This is not a publicly verified invoice. It is an anonymous account given to the media, so I treat it as a media report, not a hard financial fact.

The direction of the problem is less controversial. Bain describes companies increasing automation and AI budgets even though earlier investments have not always produced the expected savings.

AI can be cheap as a single model call and very expensive as a badly designed process.

A PLN 20,000-a-month experiment

Let us run a thought experiment.

We have PLN 20,000 a month for development work. We divide that budget between a person and AI.

95% AI / 5% human

PLN 19,000 for AI and PLN 1,000 for a person potentially buys enormous generation capacity, but almost no capacity for architecture, client contact, security, UX, integration or quality control.

You have plenty of “production”. The question is who will review it.

80/20 and 65/35

Here, the person can quickly become the bottleneck.

In a few hours, an agent can prepare more changes than one person can thoroughly read, understand, test and approve.

For highly repetitive automation, that may work. For ordinary development, not always.

50/50

A practical question emerges: can one person productively use PLN 10,000 of monthly compute?

In some applications, probably. In everyday software development, however, the constraint may be human attention rather than model power.

35% AI / 65% human

This gets more interesting.

A competent person remains responsible for the project, while several models or agents can work in parallel on coding, reviews, error analysis, testing, documentation and research.

The person need not write everything manually, but still controls the direction.

20% AI / 80% human

Around PLN 4,000 for AI and PLN 16,000 for the person.

Most of the budget stays with someone who understands the problem, makes decisions and controls the result, while AI is already a serious productivity multiplier.

For now, this looks like one of the most interesting areas to me.

5% AI / 95% human

Safe, but perhaps unnecessarily expensive.

A specialist still manually does work a machine could do faster and more cheaply: boilerplate, research, first tests, documentation or simple code transformations.

Then there is the junior-developer problem

An IZA study from 2026 describes the redefinition of entry-level software work under generative AI.

If models take over the routine tasks through which juniors learned for years, a problem emerges that goes far beyond the current project’s cost:

where will senior developers come from in five or fifteen years if we restrict juniors’ route to gaining experience?

This is not an argument for artificially preserving manual work. It is a question about developing human skills in a world where less and less needs doing by hand.

A small studio could be one of the biggest beneficiaries

This brings me to the part that interests me most.

An AI-assisted one-person studio can now deliver work that recently required far more hours or several specialisms.

Not because its owner types:

“Build an online shop”

and goes for a beer. ;)

AI can prepare a first implementation, analyse a bug, check the documentation, generate repetitive code and help with tests and documentation. The person can spend more time on decisions and review.

This is not:

AI replaced the developer.

It is more:

one person gained tools that, until recently, needed several people’s work.

Perhaps we calculate AI’s cost incorrectly

Businesses do not make money from tokens.

They make money from completed tasks.

If AI costs PLN 30 but a person spends four hours prompting, correcting and verifying it, the task does not cost PLN 30.

It costs:

PLN 30 of AI + four hours of human work.

Conversely, if a skilled specialist uses models to complete in a day what previously took three, the AI cost itself may be secondary.

Where are we in 2026?

My working hypothesis is that, for many small software teams, an interesting sweet spot may currently lie around 20–35% of resources for AI and 65–80% for people.

This is not a research finding.

It is a hypothesis based on a simple constraint: AI can produce results much faster than a person can responsibly review them.

That balance will probably shift as models become more autonomous, inference prices change and — above all — verification costs fall.

A developer’s biggest competitor may not be AI

It may be:

another developer who has learnt to use AI better.

A person without AI may be too slow.

AI without a person may produce too much that needs checking.

A good specialist with the right AI tools can combine one person’s skills with a small team’s throughput.

So a more interesting question than “Will AI take our jobs?” may be:

How much human input does AI need before it really pays off?

Perhaps software development’s future belongs to very small teams of very capable people with powerful technology at their disposal.