Why Vibe Coding Isn't the AI Utopia You Think It Is
The internet loves good vibe coding post like "AI wrote my app in 5 minutes".
I mean, attention is gold in content creation and I totally get it but it doesn't show the other side of the process. Especially about the part where people say its replacing developers.
It does raise the bar as now anyone can build a product with LLMs and vibe coding is fast. It feels smart. But it's not replacing developers. It's reminding us why they still matter.
What Is Vibe Coding?
Vibe coding is what happens when developers offload code generation to AI. You give a high-level instruction like: "Write a function to parse a config and return only the active keys." and let the AI do the rest.
The appeal is real. You get speed, fewer keystrokes, and less context-switching. The code often looks right, but that's not the same as being right.
My Experience
I've been using LLMs for code since GitHub Copilot first dropped in early 2022 so without realizing it, I've been vibe coding for quite a while.
Looking back, the evolution is undeniable. The current models are incredibly powerful. But even with all that progress, I never really felt like I was co-programming with an AI.
At best, it helped me move faster, especially through the boring parts. It felt like a supercharged autocomplete, and honestly, that was great. But today's coding models are marketed as pair programmers, and that's where the illusion begins.
Yes, the latest models are surprisingly capable. They've helped me generate things I didn't expect them to pull off. But here's the catch: it's still a coin toss. You might get exactly what you want, or something that totally misses the point. And even if it looks right, accuracy is never guaranteed.
Sure, you could write a 1000 word prompt to steer it correctly, but come on, WTF? At that point, you might as well just code it yourself. 🤷♂️
And honestly, that's to be expected. These models don't think, they run on probability, predicting the next best token. The real issue is how people treat them like some kind of god-tier dev replacement.
A Recent Issue I Faced #1
Here's what happened:
I asked the LLM to write a helper function. Simple stuff. It needed to read from a dictionary, extract some values, and return results. Instead of using dict.get(), the AI used dict.pop(). Of-course I had to give a big ass prompt, but this is the idea anyway.
At first glance, it worked.
But I realized later that this mutated the original dictionary. And that same dict was used later in the codebase. Suddenly, things were breaking.
Why? Because pop() removes the key. The AI broke a cardinal rule of clean code: never modify inputs unless that's the point. This wasn't just a bad choice, it was a sign that the LLM didn't understand intent.
It Had All the Context
The code wasn't deeply nested. It was a short function, called directly from a file.
This wasn't a case of lacking information. The LLM had everything it needed. It just didn't reason about it. It didn't realize that mutating the dict would have downstream effects.
Because it can't reason. It only predicts.
To my surprise, even the reasoning model failed this task multiple time and I had make the changes myself.
There are a lot of times I had these issues along the years but it never bothered me as I wasn't expecting them to code for me instead to assist me. But the AI bros on the internet have a different idea.
Don't get me wrong, there were days when I pushed the agents to their limits, relying on them to write nearly 80% of the code. That's exactly how this project came to life: I Vibe‑Coded My Way Into a Broken Android with ChatGPT & Python.
A Recent Issue I Faced #2
I've been trying to migrate some data-fetch logic from one data source to another data source. In theory, the job is easy: read the existing code, follow the call chain, note what each method actually returns, and rewrite the bits that need changing. In practice?
Copilot and other VS Code extensions kept telling me, "They call this method; I assume it returns X."
Gee, thanks, Copilot. I, too, can assume.🤷♂️
The whole reason I summoned an AI sidekick was so I wouldn't have to spelunk through twenty-three files at 2 AM.
Could I stuff every source file into the prompt? Sure. But by the time I've hand fed the model half my repo, I already understand the code, and I'm paying $10/month for the privilege of explaining it to a chatbot.
Weirdly, this guessing game only happens with Copilot, Gemini, and most VS Code extensions. Cursor? That thing actually reads the code. It hops through references, figures out real return types, and gives answers that don't begin with "I assume." It's not perfect (the previous issue with python code was done in cursor), but at least it behaves like it's seen my codebase before.
The Tech Is New, And That's the Point
This is bleeding-edge stuff. Tools like prompt.md, instructions.md, and AI-assisted flows are emerging to guide LLMs more effectively. We're learning how to wrangle them.
But even with those tools, this tech is not yet a silver bullet. It's powerful, but still unreliable in critical workflows. It's evolving fast, but not fast enough to replace developers.
What vibe coding is doing is shifting the developer's role:
- From author to editor.
- From builder to reviewer.
- From executor to architect.
It still needs your defensive programming habits. Your understanding of why some choices are bad even if they "work." You still hold the ownership of the things you build with it.
I did try this with multiple models GPT4 & 4.1, o3-mini, Sonnet 3.7 and few Gemini models and they all seem to have the same output except when used in Cursor.
You're Still the Engineer
AI is an incredible assistant, not a replacement.
- It can vibe. It can guess. But it can't own code.
- It can't architect. It doesn't live with the consequences of its predictions.
So sure, vibe code away. Just remember who's really accountable.
Stay Curious. Adios 👋
Comments
Post a Comment