Andrej Karpathy coined the term "vibe coding" in early 2025. It describes a development style where you prompt an AI, glance at the output, and accept it if it "feels right." No deep review. No testing. Just vibes.
I laughed when I first heard the term. Six months later, I found myself doing exactly this on a Friday afternoon. The code worked. The PR got approved. And three weeks later, that code caused a production incident that took 4 hours to resolve.
A quick application run can miss failure paths, incorrect state changes and architectural inconsistencies. Those gaps need review even when the generated code appears to work.
Figure 1. The deliberate workflow adds understanding, a pattern check and edge-case tests to acceptance of generated code.
It's not about being lazy. It's about a workflow that subtly encourages shallow engagement with generated code.[1]
The vibe coding loop:
Write a prompt describing what you want
AI generates 50-100 lines of code
You scan it for about 30 seconds
It "looks right" so you accept it
You run the app, it works
You commit and move on
Compare that to the deliberate coding loop:
Write a prompt describing what you want
AI generates 50-100 lines of code
You read each function and understand the logic
You check it against existing patterns in the codebase
You test edge cases manually
You modify what doesn't fit
You commit with confidence
If deliberate review adds 15 minutes per interaction, 20-30 interactions would add 5-7.5 hours. That is an illustrative workload calculation, so measure review effort in your own workflow before using it for planning.
In this stage, the code works but doesn't match your team's conventions. Different error handling patterns appear. Import styles vary. Some files use async/await, others use .then() chains. Nobody notices because each file is internally consistent.
Detection signal: New developers start asking "which pattern should I follow?"
AI-generated code starts introducing mini-architectures within your architecture. You'll find a file that implements its own caching layer because the AI didn't know your app already has one. Or a utility function that reimplements something from your shared library.
Detection signal: Bundle size grows without corresponding feature growth. Duplicated logic appears in code search.
By this point, the codebase has multiple competing patterns, redundant abstractions, and code that nobody fully understands. Changing one thing breaks unexpected things. Debugging takes 3x longer because you're tracing through unfamiliar patterns.
Fetch can fulfil its promise when the server returns an HTTP error, so inspect response.ok before using the body.[2]
Problems a deliberate review would have caught:
Three sequential HTTP requests that could be parallelized
No error handling on any fetch call
No response status checking (user.ok?)
The notification update marks ALL as read, not just the fetched ones
Using fetch instead of the team's API client that handles auth tokens
The function is in a file called utils.ts (it's business logic, not a utility)
The three database writes also need a transaction when the business operation requires them to succeed or fail together.[3]
Every one of these is a "vibe coding" artifact. The code ran. The tests (also vibe-coded) passed. Nobody looked closely because it was clean and readable.
After AI generates code, set a timer for 5 minutes. Spend that time reading every line and asking "why this approach?" If you can't answer for any section, you don't understand it well enough to ship it.
Require at least one meaningful modification to every AI-generated block before accepting it. Not a variable rename. A structural change that proves you understood the code. If you can't find anything to improve, you probably didn't look hard enough.
Before accepting AI code, open one similar file in your codebase and diff the approaches mentally. If they differ, the AI code needs to be modified to match your conventions.[4]
Here's what most people get wrong about vibe coding: the solution isn't to ban AI tools or add more process. It's to change the definition of done.
Right now, "done" means "it works." Change it to "it works and I can explain why every line exists." That single shift eliminates vibe coding without slowing down the team significantly.
Vibe coding feels productive. It feels like you're shipping fast. But you're actually borrowing against your future self's time. And that loan comes due with interest.
Frequently asked questions
Does using an AI coding tool count as vibe coding?
The article focuses on accepting output after a quick scan and an application run. Its deliberate workflow still uses AI, while requiring the developer to understand the logic, check existing patterns and test edge cases.
Does working code prove a change is ready to merge?
An application run exercises only the paths used in that run. Review response errors, input boundaries and database behaviour as well as the visible result, then test the failures that matter for the change.
How can a team check whether a developer understands a change?
Ask the developer to explain the code and why each part exists. Compare it with a similar file in the repository and investigate any differences in error handling, dependencies or the way state changes are applied.
Are the article’s damage stages a forecast for every team?
The stages are a proposed way to recognise inconsistency, architectural drift and maintenance difficulty. Treat their timing as an illustration and inspect the repository’s actual changes and incidents before drawing conclusions.
Five predictions for where code intelligence is heading by 2028, based on 6 years of building tools in this space. Includes what's real, what's overhyped, and a maturity model for planning.
Most code quality dashboards fail because they track too many metrics and live outside the team's workflow. Here are exactly 7 metrics and a 3-week adoption plan that actually works.
Four years of data from a fully remote engineering team across 4 time zones. Specific metrics on productivity, retention, and onboarding with the frameworks that actually worked.
A structured 30-60-90 day framework for handling engineering underperformance. Based on 14 real cases with a 64% success rate, starting with diagnosis before intervention.
Seven leadership antipatterns that look reasonable on the surface but quietly destroy engineering teams. Each one includes specific signals, real failure stories, and the framework I use to correct it.
The 10x developer myth is actively harmful to engineering teams. After tracking individual metrics vs team output, I found that the highest performers often had negative correlations with team throughput.