Will AI replace developers, or is it just another tool?

10 Nov

If we have AI here, why do we need developers?

In recent years, a great wave of expectations has risen around AI in web and app development. Today, tools like Copilot, ChatGPT, Claude, Gemini and others can write a piece of code, explain a bug or design an entire solution. So the logical question is: does it still make sense to pay developers when “AI can do it”?

I keep the AI tools open next to the editor almost all the time. I’m trying out the most common variants, watching news and videos of people who are developing AI professionally – and thanks to that I have a pretty good overview of what is possible today and what is more marketing.

In this article, I want to show you how I use AI in practice, where it really helps me, where it gets in the way – and what this means for you as a web developer and for other developers wondering if “AI will take their jobs”.

What today’s AI tools for developers can (and can’t) do

There has been a huge boom around AI tools in recent years. You may feel that you can just make a request like “Build me an e-shop” and the system will click everything for you.

The reality is a bit different.

Today’s AI can mainly:

adding code in the editor – suggesting whole code snippets based on what I’m writing,
explaining code and technology – I can ask her, “What’s this piece of code doing here?” and I’ll get a usable answer,
generate solution proposals – for example, component structure, template layout or data model design for WordPress (custom post types, taxonomy…),
help with routine tasks – refactoring, writing tests, generating documentation,
act as an agent – that is, perform multiple steps in a row: edit something, run it, check it.

That all sounds great. But there’s a catch:

AI is not an experienced developer. It’s a smart, fast, but at the same time very naive helper.

It needs someone to guide it, give it the right context, monitor its outputs and take responsibility for them.

How AI helps me in my daily work

I’ll start on a positive note. AI today is a real time saver and simplifies my work. Not in the sense of “having me write the entire website”, but as a tool that helps me be faster and more accurate.

Automatic code completion

One of the features I like best is the auto-complete code.

The AI watches what I do in the editor and tries to predict what I want to write. It offers me:

whole blocks of code,
typical patterns (form validation, API work, error handling),
repetitive parts (e.g. configurations, types, helper functions).

Practical example:

I’m writing a new piece of JavaScript for an interactive element on a website – for example a product filter, a booking form or dynamic content loading. I start writing the basic structure of the feature, and the AI sees how I’ve written the rest of the project. It offers me the rest – working with the DOM or components, handling errors, sending data to the backend or to a WordPress hook. I just go through it, edit the details, and I’m done much faster than if I’d written it all by hand.

The result: less mechanical work, more time to think about what makes sense, not exactly how to write it.

“Second brain” in search of solutions

I also often use AI as a kind of “second brain”.

I’m keeping it from her:

to explain libraries or functions I’m not familiar with,
design the structure of more complex functionality,
to find edge cases that I don’t have to think about right away.

Typical scenario:

I have a more complex piece of logic on the frontend – like a combination of filters or paging and sorting. I know what I need, but there are more options. I’ll specify the AI context and have a few options suggested. Often it will remind me of things I wouldn’t have thought of on my own until later.

Important: I’m still not an “executor of AI orders”. I am the one who chooses and decides what solutions make sense from a business, sustainability and future development perspective.

AI agents and task automation

The next level is AI agents – tools that can perform tasks independently in multiple steps.

For example:

“Go through this package of files, find all the places where a particular function is called, and edit them.”
“Unify forms across templates and add basic validation and error handling.”

Sounds fantastic. And it can be fantastic – but only if the agent is given the right context:

code rules (styleguides),
description of the site architecture or template,
clearly defined boundaries as to what they are not allowed to go into.

Without this, the agent often does more harm than good. It overwrites something it shouldn’t have touched, breaks a build, or quietly changes the behavior of a part of the application.

My experience:

if I screw up the preparation, I get a substandard result,
if I go to the trouble of setting up rules and context, the agent can do a lot of routine work that I would otherwise do for hours.

Where AI is stumbling and why you can’t do it without a developer

Now the other side of the coin. AI is great as long as you have someone watching it.

AI makes mistakes – and can say them very confidently

AI has one dangerous characteristic: when it is unsure, it will often make up an answer, but it will give it very confidently.

In practice, this means that:

invents features that don’t exist in the library at all,
uses old or invalid procedures,
designs code that looks good at first glance but crashes in real life or has security holes.

A short example from practice:

I needed to modify the database for a project. AI suggested me a “better” way of writing that looked clean and modern. But it was using a feature that didn’t exist. At first glance, there was no indication of a problem, but once deployed, this “smart” change would crash on the first real request.

An experienced developer can usually detect such errors quickly. An inexperienced specifier who blindly trusts the AI will not know that something is wrong.

Why I don’t put AI into production without checking and testing

The AI can suggest edits to dozens of files at once. That’s great… and extremely risky.

Therefore:

nothing goes into production without a code review,
I check all major AI interventions via diffs (what exactly has changed),
running tests and manually verifying key scenarios.

AI does not address how much risk you can afford. It will generate changes, but it’s not responsible for what happens if the site crashes on a Friday night. That’s still the developer’s job.

Project context and long-term development

Almost anyone can build a simple prototype with the help of AI today. Just a few prompts and you have a “finished app”.

The problem comes when:

you need to develop the app,
you connect other systems,
you tune for performance and safety,
you’re dealing with edge cases and real user behavior.

AI doesn’t know your business, your customers, or the reasons why you’ve chosen a particular architecture in the past. It may come up with a solution that looks great on paper but will tie your hands in the long run.

This is where the role of the developer is irreplaceable. You need someone who keeps the context in mind, understands the business logic and can decide when an AI design makes sense – and when it doesn’t.

“Vibe coding”: when you don’t program, you just enter instructions

You may have come across the term “vibe coding”. The idea is simple: you don’t program anything, you just describe what you want, and the AI creates the app for you.

At first glance, it sounds like a dream come true:

no learning frameworks,
no writing code,
you deal with everything “humanly”.

Reality:

The AI can overwrite or delete parts it shouldn’t have touched,
it will produce code that nobody knows
the first major problem, you don’t know where or why something broke.

Vibe coding can make sense for rapid prototypes, internal tools or experiments. But it’s certainly no substitute for an experienced developer on projects you’ve been investing in and counting on for years.

Who is more at risk from AI – juniors or seniors?

Honestly:

simpler, repetitive tasks (rewriting code, simple editing) are handled better and better by AI,
part of the typical “junior job” is really replaceable.

On the other hand – for a junior, AI is a huge opportunity:

if he knows how to ask the right questions,
if he can check the outputs,
when AI is used as a tool for learning, not as a substitute for thinking.

For a senior developer, I think it’s clear:

A senior who can use AI effectively is many times more productive than without it – and therefore even more valuable.

It can do something that AI can’t:

design the architecture,
seek compromises between quality, budget and deadline,
keep the project in good shape in the long term,
take responsibility for the entire solution.

AI “takes away” some of the routine work, but it also makes them a stronger partner for the client.

What clients should know: AI is not a magic box

From the client’s perspective, AI can seem like something that “solves everything”. Just write the brief and you’re done.

But it’s not that simple.

AI namely:

doesn’t know your business – doesn’t know how you operate, what your processes are and how you make decisions,
doesn’t know your customers – doesn’t understand their needs and expectations,
It doesn’t watch the budget or the risks – it doesn’t address what it will do to you in six months or two years.

It’s all a human job – a developer talking to you, asking you questions and translating your world into a technical solution.

AI is a tool in this system:

speeds up the work,
helps catch mistakes,
allows you to do more work in less time.

But she still needs someone to drive her.

If someone promises you that “AI will build your entire website in a week for three times cheaper”, it’s a good idea to pay attention. It may look tempting in the short term, but in the long term you’ll often end up having to rebuild the site – and that’s not cheap anymore.

What to ask as a client

When someone offers you a project “mainly through AI”, it’s worth asking:

Who will be responsible for the outcome – the human or the “AI”?
How will the changes the AI makes to the code be controlled?
Does the project have an architecture, or is everything “generated” somehow?
How will safety and performance be ensured?
Who knows the code if anything needs to be extended or fixed?

The sensible answer is not “AI will solve it”, but rather “here’s the process of how we do it – we use AI, but it’s always supervised”.

What this means for developers

If you develop websites or apps, AI is something you should pay attention to.

I think it is:

Ignore AI = risk being unnecessarily slow.
Relying only on AI = you risk becoming someone who just forwards a prompt back and forth.

Something in between is ideal:

you understand what you’re doing,
you understand technology,
you can design architecture and solve problems,
and on top of that, you’re using AI as a tool to make the job faster and easier.

Such a developer is the most valuable for the client: he will deliver a quality solution and use modern tools.

Conclusion: will AI take developers’ jobs?

I don’t think so. AI isn’t taking away our work, but it is completely changing the way we do it.

But it will take the jobs of those who refuse to move. Those who don’t want to learn new tools, don’t want to think about designing solutions, and are content to “just click code”.

For an experienced developer who can solve complex problems and can intelligently incorporate AI into the process, AI is a huge opportunity. And the good news for you as a client is that: