Introduction#
Just three or four years ago (2022 - the release of ChatGPT), writing a decent backend was a tedious process. Not because we lacked frameworks, libraries, or tools. Everything was there. Whatever. The problem was time and focus. You had to manually create models, endpoints, validation, etc. In other words, a lot of repetitive work and a lot of code that, in itself, wasn't difficult or particularly creative (unless you were doing something genuinely non-standard).
Today, that same backend can be built in a fraction of that time. Not because programmers suddenly became faster or got a Neuralink implant. Simply because something… new appeared alongside us.
Artificial intelligence in its current form isn't even close to full "intelligence" in the sense of AGI. It doesn't think like a human. It doesn't understand problems. This post illustrates it perfectly:
BUT there is something AI can be good at: coding. During the training of LLM models, absurd amounts of code were dumped into their heads-posts from Stack Overflow, repositories from GitHub, and a mass of other sources.
That's why LLM models are great at handling what is boring and repetitive for humans. They synthesize patterns. They assemble fragments into a sensible whole. In practice, this means generating project structures, APIs, database queries, or tests. The programmer writes code line-by-line less and less often, and increasingly just dictates to "someone" what needs to be done.
Therefore, this text is not about whether AI will replace programmers in a technical sense. It is about which programmers it will definitely replace and why vibecoding can be both the greatest career accelerator and the fastest road to professional stagnation.
Problems associated with this#
Along with this approach, complications have appeared. Every powerful technology, when it falls into the wrong hands, sooner or later starts causing damage. Sometimes very specific damage. A classic example is Alfred Nobel, who invented dynamite to revolutionize industry and mining. However, it quickly turned out that his invention was also perfectly suited for killing people.
It's very similar with AI. (Okay, they aren't killing us yet).
If someone who has never seen code with their own eyes starts "vibecoding", releases an app to a wider audience, and that app gains popularity, sooner or later something will go wrong. Personal data leaks. Leaks of ID CARD PHOTOS (as in the case of the Tea app security scandal). Credit card numbers. Passwords. Everything that app ever collected.
Why? Because artificial intelligence takes no responsibility for technical debt, security loopholes, or the future scalability of the system. It doesn't maintain the application.
Programming has stopped being about writing code#
The biggest change AI has brought isn't that code is written faster. That's just a side effect. The real change is that writing code has stopped being the hardest part of programming.
Today, the problem isn't how to implement something. The problem is what should be implemented in the first place, in what way, and with what consequences. Architecture, security, data flow, system responsibility boundaries. AI won't handle that for you, even if it generates very pretty files.
That's why vibecoding works great in the hands of people who already know what they are doing. And that's why it is completely dangerous in the hands of those who treat it like a magic app-making machine. AI doesn't replace the programmer. AI forces the programmer to stop being just an executor.
And since code has stopped being the problem, it's time to talk about what the problem is now.
Vibecoding#
Vibecoding is a work style where the programmer stops being a typewriter for code and starts being something like a conductor. They describe the problem, set the direction, correct details, iterate. Code is created faster because a large part of the mechanical work is taken over by AI. And cash disappears quickly too ($5/m input tokens and $25/m output tokens for Claude 4.5 Opus).
Instead of writing lines of code, you write prompts in Claude Code, Cursor, and similar tools. In itself, this isn't bad. Quite the opposite. The problem begins the moment vibecoding stops being support and starts being a replacement. When instead of accelerating the thinking process, it starts displacing it. And worse-it does this very quietly, without any red flags at the start.
Types of vibecoding#
Not every vibecoding looks the same. It's not a binary "you use AI / you don't use AI". The difference starts with who makes the decisions and who understands the consequences. We can distinguish a few levels (according to me-there will probably be those who disagree).
Light vibecoding#
The programmer knows what they are doing. They analyze the code, look closely at what the AI creates. They can write something themselves, change it, fix it, debug a faulty fragment (which, in my experience, is very frequent, practically inevitable). AI acts as a tool here. Code is created faster, but responsibility remains on the human side.
The prompt is not a substitute for knowledge, but a shortcut to an effect that could be achieved independently anyway. Usually, some tool subscription is involved (the base tier is quite sufficient). I have a Pro plan in Cursor myself, so I guess I'll categorize myself here.
This is the safest form of vibecoding because it doesn't change the foundations of the work. You still know:
- where the system boundaries are,
- which fragments are critical,
- what might crash and why.
The only difference is that you don't waste time on repetitive things.
In practice, you can recognize light vibecoding by one simple signal: if AI suddenly disappears, the project will hurt, but it won't die.
The problem is that this level is very easy to cross. And often you won't even notice the moment when light vibecoding turns into something much worse.
Moderate vibecoding#
Here, vibecoding starts to be dangerously comfortable. The programmer still grasps the basics and can fix something, like in light vibecoding. The problem is that they do it less and less often. Since AI generates code faster, why bother?
Code analysis still exists but gradually fades away. Since tests pass and the app works locally, it flies. Debugging becomes reactive-if something breaks, it gets fixed. If it works, you don't dig.
At this stage, typical symptoms begin:
- architecture is "somehow done",
- security is put off "for later",
- technical debt grows at a rapid pace.
Moderate vibecoding is treacherous because, for a long time, everything looks fine. The project develops, features land quickly. The problem only appears when something needs to be changed or rebuilt. Suddenly it turns out that the creator doesn't fully know what's happening there and often can't explain the logic (unless the AI left a comment).
In practice, you recognize this state by the fact that without AI, work could continue, but it would take much more time and be much more painful than it should be.
This is the moment where it's very easy to take the next step. And very difficult to step back from it-especially for non-technical people.
Full vibecoding#
Here, the human doesn't even know what a text editor (or IDE) is. Why bother, when there are tools that will "do everything"? v0.dev, Bolt, Lovable, CLI agents. Frontend, backend, database, auth, deploy. Click, click, and done.
You don't need to know the stack or architecture. You don't even need to sit at a computer. Just throw in an MVP description, wait a moment, and release subsequent versions. A full ride with no hands.
In the beginning, it's fun. Very fun-a bit like being on drugs. After a few or a dozen prompts, you have something that looks like a product. Everything works, the UI is pretty. Everything done solo, without a team (unless you count the AI).
And then comes the bill.
Plans for $200 a month, tokens flying like crazy. But that's not a problem-your app is about to generate huge revenue.
The real problem is different. You aren't analyzing the code at all anymore. Why would you, when you have several AI agents: one generates the project, the second debugs, the third "refactors", and the fourth counts the profits and buys private yachts (after all, your ten apps on the App Store have achieved spectacular success).
It is no coincidence that the word "human" appears at the beginning of this section, not "programmer". Because where is the programmer in all this, if the only thing being written is prompts, not lines of code?
The good sides of vibecoding#
And what's the best part? maybe not for you, but for pentesters who are just waiting for such full vibe-coded apps. Relax, you'll pay them. Or not.
Because very often, no pentester will report to you. You'll wake up with a leaked database because some bad actor exploited a vulnerability and did exactly what they wanted.
Most often, these aren't exotic vulnerabilities. No 0-days, no black magic. These are the simplest, most cliché errors that anyone knowledgeable has seen hundreds of times.
Lack of authorization on endpoints that "were supposed to be internal". The endpoint works, but no one added role checking. The result? An ordinary user can download someone else's data. Sometimes all of it at once.
That's why full vibecoding is gold not only for pentesters but primarily for people who have no ethical principles and don't intend to write you an email. They don't want a bug bounty. They want data. Or access. Or just to check how much they can break it.
Okay, maybe there are some good sides (for vibecoders). First: private projects. If you're doing something just for yourself, to make your life easier, automate some stupidity, a tool for your own use-vibecoding can be gold. You aren't endangering anyone.
Second: prototypes and proof of concepts. You want to check if something makes sense at all. Whether the idea isn't total nonsense. Vibecoding allows you to do this in one evening, which used to take a week. And that is super.
We can end with the advantages there. The good sides end where the collection of sensitive data begins. Putting it bluntly-vibecoding is super as long as the only person you can hurt with it is yourself (unless you are a real man and can handle the leak an egoist and don't care how other people's data leaks from your app).
Learning programming vs. AI (or how not to shoot yourself in the foot)#
If you are just learning to program, I'll say it straight: I do not recommend using AI as your main learning tool. And not because "AI is evil" or because you have to suffer to learn. But simply because it is very easy to learn exactly… nothing.
Programming is not about writing code. Code is just notation.
Programming is actually about:
- understanding the problem,
- being able to break it down into parts,
- knowing what is supposed to happen, in what order, and why,
- and only at the end writing code in some language.
This process should happen in your head first. Possibly on paper. You can even talk to a duck. A diagram, pseudocode, a few sentences describing the logic. Only then the editor.
AI does exactly the opposite. You get ready-made code that works. And that is the biggest problem. Because if it works, why dig deeper? Why wonder why it's like that. Why try it yourself. As a result, you learn prompting, not programming.
But when asked: why does this work or what happens if we change X, suddenly it gets quiet.
If you are learning to code, you have to struggle for a while. You have to make stupid mistakes. You have to write something wrong and then fix it. You have to spend half an hour on a bug that turns out to be a typo or a misplaced condition. This is exactly the moment when logic is built in the head.
Because if you don't have that internal logic map within you, vibecoding won't make you a programmer. It will make you a user of a tool that will stop being enough at some point.
And then we return to the beginning of this text: AI won't replace programmers. It will replace those who never became them.
Which programmers will AI definitely replace#
And will it replace? I doubt it. Maybe. But not now.
If anything, not everyone. And not "programmers" as such. AI will replace very specific types of people. Those who are already on the verge of being redundant today.
-
It will replace programmers who cannot solve problems on their own. People who rode for years on "knowing a given framework"-they learned patterns by heart without knowing how they work, following only tutorials. Without reflection.
-
It will replace vibecoders who outsourced all thinking to AI. Not those who use AI as a tool. Only those who are unable to do anything without it. If the project ceases to exist the moment the model has a technical break, it wasn't a project.
And that's probably it. Although... well, maybe AI will replace me too? And you? And all of us? I have a plan for such a case. I'll start a shrimp farm. And you?
