Kushyar Rashidzadeh

Posted on Sep 23

Vibe Coding Isn't the Problem. Not Understanding Your Code Is...

#ai #programming #vibe #coding

Vibe coding gets a lot of criticism.

And honestly, some of it is deserved.

But I don't think vibe coding itself is the problem.

The problem is what happens when we stop thinking because AI can do the thinking for us.

AI made writing code cheap

A few years ago, building a small application meant spending hours searching through documentation, writing boilerplate, debugging syntax errors, and figuring out how different pieces fit together.

Now you can describe what you want:

"Build a login form with validation, loading states, and error handling."

And a few seconds later, you have something that works.

That's incredible.

And there's nothing inherently wrong with using it.

The problem starts when the developer sees the result and thinks:

"It works. Ship it."

The dangerous part isn't the generated code

It's the lack of understanding behind it.

Imagine AI generates this:

const fetchUser = async () => {
  const response = await fetch("/api/user");
  const data = await response.json();

  return data;
};

Looks fine.

You run it.

It works.

Ship it.

Until the API returns a 500.

Or returns invalid JSON.

Or the user isn't authenticated.

Or the request takes 20 seconds.

Or the component calling it gets unmounted.

The code wasn't necessarily bad.

You just never asked what happens when things go wrong.

That's the difference between:

"AI wrote my code."

and

"I used AI to help me write my code."

The same thing happens with React

Ask an AI to fix a React state problem and you might get something like:

const addItem = (item) => {
  items.push(item);
  setItems(items);
};

Looks reasonable at first glance.

But React state shouldn't be mutated like this.

A better approach is:

const addItem = (item) => {
  setItems(prev => [...prev, item]);
};

If you understand React's state model, you'll probably catch the problem immediately.

If you don't, you might just copy the first version because:

"The AI generated it."

That's where vibe coding becomes dangerous.

AI doesn't remove the need to understand code

It changes where your effort goes.

You might spend less time writing:

boilerplate
repetitive functions
basic components
configuration
straightforward CRUD logic

But you still need to spend time on:

architecture
debugging
security
performance
edge cases
testing
maintainability
understanding trade-offs

In fact, I think these things become more important when AI writes more of the code.

Because reviewing 500 lines of unfamiliar AI-generated code isn't necessarily easier than writing 500 lines yourself.

The real skill is becoming judgment

AI can give you five different implementations.

Which one should you use?

AI can generate a database query.

Is it efficient?

AI can write authentication logic.

Is it secure?

AI can generate a test.

Does the test actually test anything meaningful?

AI can refactor your component.

Did the refactor introduce a subtle bug?

Those aren't syntax questions.

They're engineering questions.

And they're still yours.

So, is vibe coding bad?

Not necessarily.

If you're building a weekend project, experimenting with an idea, or trying to understand a new technology, there's nothing wrong with telling an AI what you want and iterating quickly.

That's one of the most useful things about these tools.

The problem is when speed replaces understanding.

There's a huge difference between:

"I don't need to write every line myself."

and

"I don't need to know what these lines do."

The first one is productivity.

The second one is technical debt waiting to happen.

AI should be your accelerator, not your autopilot

I don't think developers need to prove themselves by manually writing every line of code anymore.

That's not the point.

The point is knowing enough to question the output.

Read the generated code.

Change it.

Break it.

Debug it.

Ask why it works.

Ask why it doesn't work.

And most importantly:

Don't merge code just because an AI told you it's correct.

AI can dramatically increase how fast we build software.

But someone still needs to understand what is being built.

And right now, that someone is still you.

What's your take?

Is vibe coding making developers more productive, or are we creating a generation of developers who can build things they don't fully understand?

DEV Community