Is Vibe Coding the Root of All Problems?

We are in an era where software generation is faster than ever. With tools like Cursor or Lovable, a raw idea can turn into an app that runs smoothly on your local machine in just hours. Founders are pleased, products take shape rapidly, and momentum exceeds expectations.

But there is a question we always ask when projects scale too fast: Three months down the line, when you need to refactor a core business logic, who in the team actually understands how this system works?

The problem is rarely the quality of AI-generated code. AI writes fast, optimizes well, and usually delivers code that runs perfectly at that specific moment. The real issue is: speed over-indexes delivery at the cost of control. When software is generated faster than it can be comprehended, a project slowly loses control of its own source code.

At Cyberk, after inheriting and restructuring dozens of projects, we've identified a clear rule: AI demands discipline, and source codes demand a blueprint.

Let's dig deeper into the limitations of AI:

Models need to be fed context before they can begin reasoning. The problem is that context length is limited—around 100k tokens for small models and 1-2 million for large models like Opus. But even this is not enough to feed in the entire source code, along with requirements, images, unit tests, etc. Thus, current tools often use sessions to partition the context length. This helps the AI reason precisely within the scope it needs to.

Therefore, naturally, every time the AI operates, it cannot guarantee that every line of code it generates is correct within the holistic overview (such as code consistency, security, scalability, or architecture). That is why the developer plays the role of the coordinator. (Read more about AI-driven development).

When adding a new feature, we also typically need to check for cascading systemic changes. It requires analysis -> re-reading the source code, altering the architecture to fit the abstraction, or maintaining the design pattern. A "vibe coder" tends to want to complete the task as fast as possible, shipping as early as possible. Thus, these essential tasks are often completely ignored.

Losing Control

Because AI generates code so quickly, developers tend to push large, complex features directly to the repository. In a traditional workflow, to avoid bias, we always have a code review step. This step exists to ensure that the newly created code meets our standards and can undergo one or multiple rounds of review—checking for security, architecture, and consistency—before being merged into the main branch.

The problem that arises here is that the sheer volume of code generated overwhelms the reviewer. If a Pull Request (PR) has only 10 lines, a reviewer can easily read it thoroughly, critique it, and spot vulnerabilities. But if that number is 500 lines, they will tend to overlook minor details or just blindly approve it to get it over with. Thoroughly reading and critiquing code can take all day, whereas hitting "Approve" is incredibly tempting as a quick way to finish the review task.

Over time, this technical debt continues to accumulate. Developers gradually lose control over their source code, no longer truly understanding how the system runs beneath the hood. When the code generated by AI is not tightly controlled, minor bugs silently accumulate beneath the surface.

Losing control, people fall into a trap of over-relying on AI to solve their problems. When they encounter a bug, they immediately hand it over to AI to analyze, fix, and plan. But because they no longer grasp the core logic, they are completely blind to the side-effects that ripple through the project. This loop repeats itself: uncontrolled code regions expand, technical debt deepens, until no individual can control the system anymore.

Conclusion

I want to emphasize one thing: the root cause of the consequences of using AI to code, "vibe coding," or current trends is not entirely the fault of the AI tool itself.

The problem lies with the people using AI—we have handed over control of our source code. In the next article, we will dig deeper to find a comprehensive solution to this problem, and I will propose a strategic approach: using AI to automatically review the code generated by AI.