DEV Community: Junn Xavier Adalid

The Uncomfortable Reality: Vibe Coding

Junn Xavier Adalid — Wed, 29 Apr 2026 12:55:08 +0000

But there is another side of AI coding that we need to talk about.

In reality, many modern developers are no longer using AI only as a tool or assistant. Some are using it as the main developer.

This is what people now call vibe coding.

The idea sounds exciting: you describe what you want, the AI generates the system, you run it, you fix errors by pasting them back into the AI, and after a few minutes you have something that looks like a working app.

And honestly, that is impressive.

But it is also concerning.

Because building software is not only about making something run.

A system can run and still be badly designed.

A feature can work and still be insecure.

A login page can look correct and still have broken authentication.

An API can return the right response and still expose user data.

A payment system can pass a simple test and still fail in real-world edge cases.

That is the part many people miss.

AI can generate code very fast, but fast code is not automatically good code.

According to the 2025 Stack Overflow Developer Survey, AI tool usage is already very common: 84% of respondents said they use or plan to use AI tools in their development process, and 51% of professional developers use them daily. But the same survey also shows a trust problem: more developers distrust the accuracy of AI tool output than trust it, and only a very small percentage highly trust it.

That says a lot.

Developers are using AI more, but they do not fully trust it.

And they should not blindly trust it.

The Problem Is Not AI Coding. The Problem Is Unreviewed AI Coding.

I do not think AI coding itself is bad.

Actually, AI can be very useful.

It can help with boilerplate, debugging, refactoring, tests, documentation, and learning. It can make a good developer much faster.

The real problem starts when a developer accepts AI-generated code without understanding it.

This becomes risky when the AI is deciding things like:

database structure
authentication flow
authorization rules
API design
file structure
error handling
validation
security logic
deployment configuration
system architecture

At that point, the developer is no longer just getting help.

The developer is giving up control.

That is a big difference.

Using AI to write a function is one thing.

Using AI to design your whole system without reviewing the architecture is another thing.

Can AI-Generated Software Be Secure?

Yes, it can be secure.

But only if the developer or team treats AI-generated code like untrusted code that needs review.

The code should still go through:

human code review
security review
testing
threat modeling
dependency checks
static analysis
access control checks
proper architecture review
production monitoring

Without those steps, AI-generated software can easily become risky.

A study on AI-generated backend applications found that even the best tested model reached only 62% code correctness, and around half of the correct generated programs could still be exploited. That is important because backend systems are usually where authentication, authorization, user data, and business logic live.

Another large-scale analysis of AI-generated code from public GitHub repositories found thousands of CWE security weakness instances across many vulnerability types. The study also noted that vulnerability rates differed by language, with Python showing higher rates than JavaScript and TypeScript in their dataset.

This does not mean every AI-generated codebase is insecure.

But it does mean we should not assume AI-generated code is safe just because it works.

Why Security Is Hard for AI

Security is not just about adding a few lines of code.

Security depends on context.

AI might know how to create a login system, but does it know your real business rules?

Does it know which users should access which data?

Does it know your company’s security standards?

Does it know your threat model?

Does it know what should happen when a user changes roles?

Does it know how your payment flow should behave when something fails halfway?

Usually, no.

That is why AI can generate code that looks correct but misses important security controls.

The Cloud Security Alliance explains that AI coding assistants can introduce risks because they do not inherently understand an application’s risk model, internal standards, or threat landscape. They can repeat insecure patterns, take shortcuts, omit necessary security controls, or introduce subtle logic errors that are hard to notice.

This is especially dangerous because AI-generated code often looks clean.

And clean-looking code can make developers feel safe.

But readable code is not the same as secure code.

The Most Dangerous Mindset

The most dangerous mindset is:

“The app works, so the code must be fine.”

That mindset was already risky before AI.

With AI, it becomes even more dangerous because developers can now create bigger systems faster than they can understand them.

A developer might generate a dashboard, authentication system, backend API, database schema, admin panel, and deployment config in one afternoon.

That sounds powerful.

But if they did not review the code, then they do not really know what they built.

They only know that it appears to work.

That is not engineering.

That is gambling.

AI Can Write Security Code, But It Cannot Own Security Responsibility

Some people may say:

“But AI can also implement security.”

Yes, it can.

AI can generate password hashing code.

AI can suggest input validation.

AI can create middleware.

AI can add authentication.

AI can write tests.

AI can explain vulnerabilities.

But security is not just implementation.

Security is verification.

Security is asking:

Is this the right control?
Is it applied everywhere?
What happens in edge cases?
Can a normal user access admin data?
Are secrets exposed?
Are tokens handled safely?
Are permissions checked on the server?
Is the database query safe?
What happens if the request is modified?
What happens if the user is malicious?

AI can help answer those questions, but the developer still needs to ask them.

The UK National Cyber Security Centre recently warned that AI-generated code has benefits, but it must not come at the expense of security. The NCSC also said AI tools used to develop code need to be designed and trained so they do not introduce or propagate unintended vulnerabilities.

That is the key point.

AI can help with security, but it should not be the only security reviewer.

Manual Review Still Matters

This is why manual review is still important.

Not because humans are perfect.

Humans also write insecure code.

But humans understand context in a way AI often does not.

A developer can look at the system and ask:

“Does this design actually make sense for our users, our data, and our risks?”

AI may generate the code, but the developer must still understand the architecture.

OWASP describes secure code review as a manual process for finding vulnerabilities that automated tools often miss, especially issues involving application logic, data flow, implementation details, and context-specific security problems.

That matters even more in the age of AI.

Because when code is generated faster, review becomes more important, not less important.

So, Is Software Still Secure Nowadays?

The honest answer is:

Some software is secure. Some software only looks secure.

AI does not automatically make software insecure.

But careless AI dependence can absolutely make software more dangerous.

A team that uses AI properly can still build secure systems if they have strong engineering practices.

But a developer who vibe codes an entire production system without reviewing the code, architecture, permissions, and data flow is creating serious risk.

The scary part is not that AI can write code.

The scary part is that AI can make inexperienced developers feel like they understand a system they have not actually studied.

That is where the danger starts.

My Take

I think AI coding is here to stay.

Developers will keep using tools like Claude Code, Codex, GitHub Copilot, Cursor, and other AI coding assistants because they are useful and fast.

But speed should not replace understanding.

The future developer should not be someone who avoids AI.

But the future developer also should not be someone who blindly accepts everything AI writes.

The best developer is the one who can use AI, question AI, review AI, and still understand the system deeply.

Because at the end of the day, users do not care whether the code was written by a human or generated by AI.

They care if the software works.

They care if their data is safe.

They care if the system is reliable.

And if something breaks, the AI will not be responsible.

The developer will be.

AI can generate code in minutes, but it cannot guarantee that the code is correct, secure, scalable, or maintainable. That responsibility still belongs to the developer.

AI Coding vs Manual Coding: Which Makes Developers Faster?

Junn Xavier Adalid — Wed, 29 Apr 2026 12:50:29 +0000

AI tools are everywhere in software development now.

A few years ago, if you wanted to build a feature, you had to search the docs, read Stack Overflow answers, write the code line by line, debug everything yourself, and slowly figure out what was going wrong.

Now, things feel different.

With tools like Claude Code, Codex, GitHub Copilot, and Cursor, developers can generate code, explain errors, refactor files, write tests, and understand unfamiliar projects much faster than before.

But this raises an important question:

Are AI coding tools actually making developers faster, or are they making us too dependent on them?

I do not think this is simply a battle between AI coding and manual coding.

The better question is:

When should developers use AI, and when should they still code manually?

Let’s break it down.

What Manual Coding Looks Like

Before AI coding tools became popular, most developers followed a more traditional workflow.

Usually, a developer would:

Read the official documentation
Search Stack Overflow or GitHub issues
Write the code manually
Debug errors step by step
Refactor the code by hand
Write tests from scratch
Spend time understanding the framework, syntax, and architecture

This process is slower, but it teaches you a lot.

When you write code manually, you are forced to understand what is happening. You need to think about the logic. You need to know why something works and why something breaks.

That is not always fun.

Sometimes it is frustrating. Sometimes you spend hours fixing one small bug. Sometimes you read the same documentation page ten times before it finally makes sense.

But that struggle builds real skill.

Manual coding helps developers build strong fundamentals because they are not just copying a solution. They are learning how to think through a problem.

What AI-Assisted Coding Looks Like

AI-assisted coding feels very different.

Instead of doing everything from scratch, developers can now ask AI tools to help with many parts of the development process.

For example:

GitHub Copilot can suggest code while you type.
Cursor can understand your codebase and help you edit files faster.
Claude Code can explain code, generate changes, and help with larger development tasks.
Codex can help reason through coding problems and execute programming tasks.

This changes the developer workflow.

You are no longer only writing code. You are also giving instructions, reviewing suggestions, fixing generated code, and deciding what should or should not be accepted.

In a way, the developer becomes more like a guide.

The AI can generate output quickly, but the developer still needs to understand the problem and judge whether the output is correct.

That part is very important.

AI can help you move faster, but it does not remove your responsibility as a developer.

Where AI Makes Developers Faster

There are some areas where AI clearly saves time.

Not every coding task requires deep creative thinking. Some tasks are repetitive, predictable, and time-consuming.

That is where AI is very useful.

1. Boilerplate and Repetitive Code

Every developer knows this kind of work.

You need to write another CRUD function.

Another form validation.

Another API request.

Another test skeleton.

Another reusable component.

These tasks are important, but they can also feel repetitive.

AI tools are great for this.

For example, instead of manually writing the same structure again and again, you can ask AI to generate a starting point. Then you can review it, adjust it, and make it fit your project.

This does not mean the AI is doing the whole job.

It simply removes some of the boring setup work so you can focus on the actual logic.

That alone can make developers much faster.

2. Debugging Becomes Less Painful

Debugging is one of the most time-consuming parts of programming.

Sometimes an error message is clear.

Other times, it looks like complete nonsense.

Before AI tools, developers usually had to copy the error message, search online, open five different tabs, compare answers, and test different fixes.

Now, you can ask an AI tool:

“Why am I getting this error?”

And it can usually give you a possible explanation.

Of course, AI is not always right.

Sometimes it gives a wrong answer with full confidence. That is why developers still need to think carefully and test the solution.

But even when AI is not perfect, it can give you a starting point.

And in debugging, a good starting point can save a lot of time.

3. Easier Context Switching

Modern developers are expected to know a lot.

One day you are working on the frontend.

The next day you are fixing a backend API.

Then you are touching the database.

Then deployment breaks.

Then tests fail.

Then documentation needs updating.

That is a lot of context switching.

AI helps reduce the friction.

If you are not familiar with a part of the stack, you can ask AI to explain the code, summarize a file, or suggest how something works.

This does not make you an expert instantly, but it helps you move forward.

Instead of getting completely stuck, you can understand enough to continue working and then improve from there.

4. Faster Learning

AI tools can also make learning faster.

Before, learning a new framework usually meant spending hours reading documentation before building anything useful.

Now, you can learn while building.

You can ask questions like:

“What does this function do?”
“How do I structure this component?”
“Why is this API call failing?”
“Can you explain this code like I am new to it?”
“What is the better way to write this?”

This makes experimentation easier.

For beginners, this can be very helpful because they can get explanations immediately instead of being stuck for hours.

But there is a warning here.

Learning with AI is useful only if you actually try to understand the answer.

If you just copy and paste without thinking, you may finish the task faster, but you will not really grow as a developer.

Where Manual Coding Still Wins

AI is powerful, but it is not better at everything.

There are still areas where manual coding and human judgment matter a lot.

In fact, this is where good developers stand out.

1. Architecture and System Design

AI can suggest patterns, but it does not fully understand your product, your users, your team, or your long-term goals.

Big engineering decisions still need human thinking.

For example:

Should this logic be handled on the frontend or backend?
Is this abstraction actually useful?
Will this database structure scale later?
Is this code easy for other developers to maintain?
Are we solving the real problem or just adding more complexity?

These are not just coding questions.

They are engineering decisions.

AI can give suggestions, but the developer has to decide what makes sense.

Bad architecture can make a project painful for months or even years. That is why speed is not the only thing that matters.

2. Deep Understanding

This is one of the biggest risks of AI-assisted coding.

A developer can generate working code without fully understanding it.

At first, that feels great.

The feature works.

The error is gone.

The code looks clean.

But later, when something breaks, the problem becomes clear.

If you do not understand the code, you cannot maintain it properly.

This becomes dangerous when:

The bug is complex
The project grows larger
Edge cases appear
Performance matters
Other developers need to work with your code
The business logic becomes more complicated

Manual coding forces you to slow down and understand the details.

AI can sometimes skip that learning process.

That is why developers need to be careful.

Using AI is fine. Blindly trusting it is not.

3. Security and Correctness

AI-generated code can look correct even when it is not.

This is especially risky in sensitive parts of an application, such as:

Authentication
Authorization
Payments
Database queries
User permissions
Production infrastructure
Security rules
Performance-critical code

In these areas, “it works” is not enough.

The code needs to be safe.

AI might generate something that passes a basic test but fails in real-world situations. It might miss an edge case. It might use an insecure pattern. It might misunderstand your requirements.

That is why developers must review AI-generated code carefully.

AI can help write the code, but the developer is still responsible for what gets deployed.

4. Engineering Responsibility

This is the part people sometimes forget.

AI does not take responsibility for your software.

If the code breaks in production, the AI is not the one fixing it.

If user data is exposed, the AI is not accountable.

If the payment logic fails, the AI is not responsible.

The developer is.

That means developers still need to:

Review the logic
Test edge cases
Understand the business rules
Check for security issues
Keep the code maintainable
Make sure the solution actually solves the problem

Writing code is only one part of software development.

The harder part is making sure the code is correct, reliable, and safe to maintain.

AI can assist with that, but it cannot replace the developer’s judgment.

The Real Tradeoff: Speed vs Understanding

So, does AI make developers faster?

Yes, definitely.

But speed is not the full story.

A developer who uses AI well can save time on repetitive tasks and focus more on important decisions.

That is a good thing.

But a developer who uses AI to avoid thinking may become faster in the short term and weaker in the long term.

That is the real tradeoff.

The problem is not AI coding.

The problem is careless AI dependence.

There is a big difference between these two:

Good AI-assisted coding:

You use AI to speed up repetitive work, explore ideas, understand code, and improve your workflow.

Bad AI-assisted coding:

You accept whatever AI gives you without reading, testing, or understanding it.

One makes you better.

The other makes you risky.

My Take on Claude Code, Codex, Copilot, and Cursor

Tools like Claude Code, Codex, GitHub Copilot, and Cursor are changing how developers work.

They make coding feel more conversational.

Instead of only typing everything manually, developers can now describe what they want, ask questions, generate drafts, and improve the code through iteration.

These tools are especially useful for:

Repetitive code
Code explanation
Debugging help
Refactoring
Test generation
Quick prototypes
Documentation drafts
Understanding unfamiliar codebases

But they do not remove the need for strong fundamentals.

Actually, I think the opposite is true.

The better you understand programming, the better you can use AI.

A skilled developer can look at AI-generated code and quickly see what is useful, what is wrong, and what needs to be changed.

A beginner can also benefit from AI, but they need to be careful not to skip the learning process.

AI does not replace skill.

It amplifies it.

A strong developer with AI becomes much faster.

A weak developer with AI may also become faster, but they can also become more dangerous if they do not understand what they are shipping.

So, Which One Makes Developers Faster?

If we are only talking about speed, AI-assisted coding wins in many situations.

It helps developers move faster when writing boilerplate, debugging common issues, generating tests, and exploring new ideas.

But if we are talking about long-term growth, manual coding still matters.

Manual coding builds the foundation.

AI-assisted coding builds speed on top of that foundation.

The best developers will probably use both.

They will use AI when it saves time, but they will still know how to think, debug, design, and code manually when needed.

Final Thoughts

AI is not the end of manual coding.

And manual coding is not outdated.

What is changing is the way developers work.

We no longer need to write everything from scratch all the time. AI can reduce repetitive work, explain confusing code, and help turn ideas into working software faster.

But speed without understanding is dangerous.

The future of software development is not about AI replacing developers.

It is about developers learning how to work with AI without losing their ability to think deeply.

The best developers will not be the ones who avoid AI completely.

They also will not be the ones who depend on AI for everything.

The best developers will be the ones who know when to use AI, when to question it, and when to sit down and code manually.

Because at the end of the day, AI can help you write code faster.

But you still need to understand what you are building.