Vibe coding: challenges and how to use it well

AI-assisted programming, known as vibe coding, is drawing attention. Tools such as Cline, Roo, Claude Code, and Aider have appeared one after another, and programs can now be generated automatically from nothing more than natural-language instructions. Tools specialized in building UIs, such as V0 and bolt, have also appeared, making prototype development far easier than before.

On social media, however, the benefits get most of the attention, while many problems have been pointed out for enterprise systems and software that must be operated over the long term. This article sorts out the cases where vibe coding fits and the cases where it does not, and proposes concrete approaches for using AI coding wisely.

What is vibe coding

Vibe coding is a new programming approach in which you give instructions to AI in natural language and use the generated code “as is.” Instead of developers writing code by hand as before, AI generates the code automatically, and humans move development forward by testing, fixing, and adjusting it.

The approach was popularized by Andrej Karpathy, a co-founder of OpenAI who also served as AI lead at Tesla. He proposed the concept on X in 2025, and his novel idea that “the software you need takes shape just by giving instructions in natural language” drew wide attention. While it dramatically speeds up the development of prototypes and personal tools in particular, the risks and challenges of introducing it into large, long-lived systems are also being debated.

Where vibe coding does not fit

Building enterprise information systems
- Most of these systems require long-term maintenance, so future modification and operating costs may rise sharply
- AI-generated code becomes a black box, so troubleshooting takes time
Complex software
- In systems that need many modules and integrations, leaving the work to AI without understanding the details easily leads to unexpected bugs and defects
- Edge cases and specific business rules may not be handled adequately
- Optimizing and performance-tuning AI-generated code is difficult

Where vibe coding fits

Prototyping
- Ideal for building prototypes where speed matters and long-term maintenance is not expected
- A big advantage when you want to have a working sample ready in a short time to validate an idea or give a demo
Disposable software
- Tools for a one-off event or for use over only a short period
- Operation and maintenance barely need to be considered, so an AI-driven approach rarely causes problems
Data processing and analysis scripts
- One-time analyses and routine data processing tasks
- Processing that does not involve detailed business logic
Simple UI building
- Design-focused UI development such as prototypes, landing pages, and simple admin screens
- Gives designers and marketers an environment where they can freely experiment

Comparison of major AI coding tools

Tool	Features	Strong languages / frameworks	Pricing model	Best suited for
Claude Code	AI assistant you operate in natural language from the terminal. Strong code comprehension; also handles Git operations and pays attention to safety.	Python, JavaScript, TypeScript	Pay-as-you-go (API tokens)	Reading and modifying complex code, LLM-based local assistance
Cursor	AI-integrated editor forked from VS Code. Real-time completion, awareness of whole-file context, intuitive UI.	Python, JavaScript, TypeScript, and others	Subscription	Everyday development support, quick fixes and experiments with AI
Aider	CLI-based. Integrates with Git: ask the AI for code changes and it commits them automatically. Supports multi-file edits.	Python, JavaScript, Rust, and many others	Free (OSS) + separate API charges	Improving existing repositories, code maintenance, interactive development
v0	Generates UI instantly from text prompts. Outputs code built on Tailwind + shadcn and can deploy right away.	React, HTML, Tailwind CSS	Subscription (some free usage)	Landing page and UI prototypes, quick mockups, UI design without coding
Bolt	Builds entire web apps from natural language. Code generation, instant execution, and deployment all happen in the browser.	JavaScript, React, and others	Subscription (some free usage)	Full-stack prototypes, learning, development automation
Cline	AI in VS Code that autonomously edits code, builds, runs UI tests, and operates the system. Human-in-the-loop design.	Multi-language (mainly JavaScript-based)	Free (OSS) + separate API charges	Advanced automation, local-first use, UI testing and CI pipeline integration
Roo Code	Enhanced version based on Cline. Diff-based editing, faster performance, mode switching (PM/QA, etc.), and custom agents.	Multi-language (TypeScript, React-based)	Free (OSS) + separate API charges	Code analysis, refactoring, test support, flexible role handling
Devin	Autonomous AI engineer. Handles design, implementation, debugging, testing, and deployment on its own. Built-in terminal and browser.	JavaScript, Python, and many others	$500/month + additional usage charges (ACU-based)	Bug fixes, refactoring, internal tool development, automated E2E testing, prototypes

The fundamental problem with vibe coding

Code produced by vibe coding has a problem: it is “hard for anyone but AI to modify.” When humans write code themselves, they hold a mental model of it in their heads, so modifying and extending it is easy. When the work is left to AI, however, they end up handling code without understanding in detail how it works.

As a result, as the code grows more complex, maintaining it by hand becomes even harder, so further development also comes to depend on AI. There is also a risk that the AI itself can no longer handle code that has become too complex, and the system may eventually turn into one that is difficult to maintain.

Why vibe coding cannot build large-scale software

AI-generated code may appear to work at first glance, and it may even pass unit tests. However, working and being correctly designed are entirely different things.

Collapse from “piling up locally optimal code”

Current AI is good at producing “plausible code” for a local context. Put the other way around, though, this means it does not consider the optimum for the system as a whole.

For example, if you ask AI to build an API endpoint, it will:

Write parameter validation on the spot
Expand logic inline
Embed shared processing directly instead of abstracting it

In this way, it tends to pile up “quick-fix code” written only for the task at hand.

This may not be a problem for a small project, but as features grow:

Duplicate logic spreads across the codebase
Conditional branches become cluttered
Boundaries of responsibility become blurred
Side effects and dependencies are hidden in local spots

“Structural distortions” like these quietly accumulate.

Small deviations cause total collapse

In construction terms, this is like building a tower while continuing to use beams and columns that are “ever so slightly bent.” Each member on its own may be “within tolerance,” but when dozens or hundreds of them together support the structure, the whole ends up badly distorted.

Moreover, in programming you cannot see at a glance that something is “leaning.” Only when trouble occurs do you find yourself digging for the design rationale behind “why was this code written this way?”, but the AI never leaves a record of the reasoning behind its decisions.

In other words, the structure keeps accumulating “code whose reasons nobody can explain.”

The spiral of having AI fix systems AI built

Worse still, because humans cannot fix the AI-generated code produced this way, they end up relying on AI again.
However, AI always generates code probabilistically, so there is no guarantee that the exact same instruction will produce the same code as last time.
This means that debugging and fixing become a roll of the dice.

If you are lucky, the problem may be solved. If you are unlucky, you simply introduce another bug.

A codebase that falls into this state:

Can no longer be fully grasped by humans
Gets harder to rein in the more you rely on AI
Suffers unpredictable side effects with every change
Cannot keep refactoring or documentation up to date

It enters what is, in effect, a technical debt spiral.

What to delegate to AI, and what not to

To avoid this kind of structural breakdown, you need to draw a clear line in how you use AI.

Safe to delegate	Should not be delegated
Format conversion, utility functions	Architecture design, separation of responsibilities
Generating and completing test scaffolding	Interpreting domain knowledge and deciding on the implementation approach
Generating routine CRUD operations	Tuning non-functional requirements (performance, security)
Configuration file templates (Dockerfile, YAML, etc.)	Overall system design and dependency management

Using AI as a coding partner is highly effective, but humans should always keep “the responsibility for building the overall structure of the system.”

Divide and conquer - the right approach to AI coding

To use vibe coding effectively, an essential principle is to adopt the idea of “divide and conquer.”

Build large things by splitting them up

Thorough modularization
- Instead of developing a large feature with a large amount of code, break it down into small functional units
Avoiding uncertainty and fat tails
- When you develop a large feature, unexpected errors and problems increase exponentially
- By building small and validating repeatedly, you can find critical problems early
The Lego block philosophy
- Design software as a collection of small parts
- Each part has a clear function and responsibility, and the parts are combined to build the whole system
- Define interfaces clearly so that parts remain interchangeable

The role of experienced developers and human-led development

Software development experience is indispensable
- Judging the best way to divide a system requires the knowledge of experienced developers
- Architecture design and module boundary decisions should be made by humans, not AI
Human-led development with a long-term view
- As long as the software must be maintained over a long period, humans, not AI, need to understand the code and keep improving it
- Use AI as a tool, while humans keep ownership and understanding of the system

Using AI in software development based on the divide-and-conquer principle is an important strategy for balancing short-term productivity gains with long-term maintainability. The key to sustainable software development is not to leave everything to AI, but to develop in a way that draws on human experience and judgment.

Approaches to using AI in coding to boost productivity

There is no need to reject vibe coding outright. By using it for the right tasks, you can fully achieve AI-driven gains in development efficiency. Here are some recommended concrete examples.

Let AI add comments to code
- Have it automatically generate explanatory comments for code written by humans
- This makes the code easier to understand during later maintenance
Have AI generate small utility functions
- Let AI write single-purpose functions, such as specific calculations or format conversions
- Humans handle the large-scale structure and overall design
Assistance with writing unit tests
- Add more test cases on top of test code that AI generated automatically
- Speeds up the test-driven development cycle
Reviews and refactoring suggestions
- Have AI review code written by humans, or get refactoring suggestions from it
- Security vulnerabilities and readability issues can be detected early
Analyzing existing code and writing design documents
- Have AI analyze the codebase of a large project and use the results to generate documentation and visualize dependencies
- Use it as a support tool for understanding the overall structure
Generating configuration files for Terraform, GitHub Actions, Dockerfiles, and more
- Have AI generate configuration files for infrastructure setup and CI/CD pipelines
- Generating boilerplate code automatically reduces configuration mistakes

Summary

For prototyping and short-lived projects, actively using vibe coding is effective
For enterprise systems meant for long-term operation and complex software, there are many risks, so it must be introduced carefully
It is important to limit the work you hand to AI and keep the code within the range that humans can fully understand