The cost is not zero

Every few weeks I come across another article, LinkedIn post or enthusiastic founder explaining that AI has fundamentally changed software development and, therefore, software should now become almost free.

Usually the reasoning is fairly straightforward. AI writes code. Code used to take developers time. Therefore developers are no longer the expensive part.

I understand where that idea comes from. I also understand why clients ask the question, because if you don't work in software yourself, it genuinely looks like developers have suddenly acquired a magical intern who works twenty-four hours a day without complaining, doesn't drink coffee and somehow knows every programming language ever invented.

The problem is that people confuse writing code with engineering, and those have never been the same thing.

At We Do Dev Work we use AI every single day, and I honestly wouldn't want to go back to developing software without it. New models appear almost monthly, coding assistants keep improving, research that once consumed half an afternoon now often takes twenty minutes and repetitive work that nobody particularly enjoyed doing in the first place can frequently be generated before you've even finished your coffee. Ignoring those improvements would simply be bad business. At the same time, the more hours you spend working with these tools, the more obvious it becomes where they are brilliant, where they are merely useful and where they are still confidently digging a hole for you while insisting they're building a fancy Belgian bridge over Sukhumvit.

That distinction matters far more than people realise.

AI genuinely makes us faster

Let's start with something that shouldn't even be controversial.

AI absolutely saves time.

If I ask it to generate another CRUD endpoint, convert a Figma design into a React component, write boilerplate unit tests, explain an unfamiliar library or refactor a repetitive piece of code, it will usually produce something useful remarkably quickly. Sometimes it is almost exactly what we would have written ourselves, sometimes it needs adjustments and occasionally it produces complete nonsense, but even then it often gives us a starting point that is better than an empty file.

That productivity gain is real.

Projects that would have taken six weeks a few years ago may now take four or five, depending on the complexity. Research is faster, documentation improves, repetitive implementation becomes significantly less painful and developers simply spend fewer hours performing mechanical tasks that add little value to the client.

If you are paying a software agency, you should benefit from that.

Pretending AI changes nothing would be just as dishonest as pretending it changes everything.

Writing code was never the expensive part

This is where I think the discussion usually goes off the rails.

People imagine software development as someone sitting behind a keyboard typing very complicated-looking code all day, as though typing itself is somehow the valuable part.

It isn't.

Developers are not paid because they know where the semicolon belongs.

They're paid because somebody has to understand your business before writing a single line of code. Somebody has to decide how a feature fits into an architecture that hopefully survives the next five years instead of the next five weeks. Somebody has to think about performance, security, scalability, maintainability, integrations, future requirements, database design, deployment strategies and all the unpleasant edge cases nobody mentions during the sales meeting.

Those decisions were always the expensive part.

AI hasn't removed them.

If anything, it has made them even more important because generating code has become dramatically easier than deciding whether that code belongs in your system at all.

AI isn't free either

There is another assumption quietly hiding underneath all this enthusiasm, namely that AI itself somehow costs nothing because you're chatting with it through a browser.

That might be true if you're asking for tonight's dinner recipe.

Professional software development is a very different story.

There are premium coding assistants, subscriptions to multiple language models because none of them are the best at everything, research platforms, security tools, automated code review, cloud infrastructure, API usage, token costs and enough experiments with new tooling to ensure your engineering team actually stays ahead instead of discovering six months later that the rest of the industry has moved on without them.

None of those costs are outrageous individually.

Together they become another serious line on the monthly budget.

Just like AWS.

Just like GitHub.

Just like any professional tool worth using.

AI makes bad developers faster too

This is probably the part that receives the least attention.

People often say AI makes junior developers more productive.

That's true.

What they forget to add is that it also makes inexperienced developers much faster at producing code that should never reach production.

Ten years ago an inexperienced developer might spend an entire day struggling towards a mediocre solution.

Today that same developer can generate five mediocre solutions before lunch.

The quantity has improved enormously.

The quality depends almost entirely on the person reviewing it.

That's because AI doesn't really understand your business, your architecture or your long-term maintenance strategy. It predicts what likely comes next based on enormous amounts of training data, which is incredibly impressive technology, but prediction and engineering are not the same profession.

An experienced engineer reads generated code almost like an editor reads a newspaper article. They immediately notice inconsistencies, recognise dangerous shortcuts, question assumptions and often rewrite significant parts before anyone else ever sees them.

Someone with less experience frequently does the exact opposite.

If the AI sounds confident, they assume it must be right.

Unfortunately, software doesn't care how convincing the explanation was.

It only cares whether it works.

Senior engineers have become more valuable, not less

One of the great ironies of the AI era is that many people expected experience to become less important.

I would argue the exact opposite has happened.

The better the engineer, the more value they usually extract from AI.

Not because they write better prompts, although the internet seems strangely obsessed with that idea, but because they know which questions to ask, which suggestions to reject, which shortcuts create technical debt and which elegant-looking solutions will become absolute nightmares six months later.

The difference between a senior engineer and a junior engineer was never measured by typing speed.

Today it certainly isn't.

Faster development creates new work

There is another interesting side effect that we notice internally.

Developers write considerably more code than they did only a few years ago.

That sounds wonderful until you remember that every extra line of code also needs reviewing, testing, documenting, securing, maintaining and eventually understanding by somebody who wasn't even employed when it was originally generated.

In other words, AI has made producing software faster.

Owning software certainly hasn't become easier.

If anything, good quality assurance has become even more valuable because AI is exceptionally good at producing code that looks correct during a code review but quietly breaks when confronted with real users doing wonderfully unpredictable things.

That means testing, security reviews, accessibility, performance analysis and proper QA remain every bit as important as they were before. If your software processes payments, personal information or business-critical data, trusting generated code without verification isn't innovation.

It's gambling.

So... has software become cheaper?

Yes.

And no.

Routine implementation is faster.

Research is faster.

Documentation is better.

Many repetitive tasks that once justified hours of development can now be completed in a fraction of the time.

Clients deserve to benefit from those efficiencies.

But the engineering behind successful software, the architecture, the business analysis, the difficult technical decisions, the quality assurance, the security reviews and the experience required to know when the AI is quietly leading you in the wrong direction, haven't disappeared.

Those have become more valuable, not less.

Perhaps the biggest misconception is that AI replaces developers.

In reality, it replaces repetitive work, which is exactly what good tools have always done. We don't romanticise manually deploying software anymore because CI/CD exists, and nobody wishes we still wrote assembly language for every application either. Better tools have always changed our profession.

AI simply happens to be the biggest one we've seen in decades.

The companies that will benefit most from it won't necessarily be the ones trying to replace developers with AI. They'll be the companies that combine experienced engineers with better tools, because that combination genuinely delivers better software, faster and often at a lower cost, without sacrificing quality along the way.

It's admittedly a much less exciting headline than "AI will replace programmers next year", but reality has always been slightly disappointing for people looking for simple answers.

So yes, AI has fundamentally changed software development.

No, the cost is not zero.

And if someone confidently tells you that software has become almost free because AI writes the code now, there's a fair chance they haven't actually built much software lately.