Describe an idea, ask an artificial intelligence to generate the code, and test the result. If something fails, return the error and continue making changes until it works. This is how a useful tool can begin, even without knowing in detail how it is built.
This development approach, known as vibe coding, facilitates experimentation and opens possibilities for people with varying technical knowledge. It also raises a question: what happens when what we’ve created needs to be reliable, maintained, and evolved?
We review the origin of the concept and its possibilities with Roberto Gómez, Head of Frontend at MindDen, who shares his experience and the limits he would place on this practice.
Where vibe coding comes from.
In February 2025, Andrej Karpathy, an artificial intelligence researcher, coined the term vibe coding. He described a way of programming where he let AI generate the code, accepted changes without reviewing them, and returned errors for the AI to try and correct. He placed it in the realm of low-risk projects and experimentation.

Shortly after, developer Simon Willison, also known as the co-creator of Django, highlighted a distinction: programming with AI assistance does not necessarily equate to vibe coding. If a person reviews the generated code, understands what it does, and rigorously tests it, they are developing software with AI assistance. Vibe coding, in its original sense, means progressing without that review, guided primarily by the visible outcome.
The tools may be the same; what changes is how we work with them and how much we understand what they produce.

Simon Willison is the creator of Datasette, an open-source tool for exploring and publishing data. He currently works full-time developing open-source tools for data journalism, based on Datasette and SQLite.
Before dedicating himself to independent open-source development, Simon was Director of Engineering at Eventbrite. He joined Eventbrite after the acquisition of Lanyrd, a Y Combinator-funded company he co-founded in 2010.
He is also the co-creator of the Django web framework and has been writing about web development and programming on his blog simonwillison.net since 2002.
An example of vibe coding: the translation plugin.
Gómez has experimented with this approach. One example he shares is a translation plugin: he managed to develop it with the help of an agent and has guided corrections based on team feedback.
The experience has allowed him to quickly and conveniently solve a need. At the same time, he recognizes a limitation in his ability to diagnose what might happen.
Having generated code this way, I don’t know how it works internally, and if there were any problems, it would be much more difficult to diagnose and solve them.
He summarizes his experience as “fast and convenient, but unstable”. The limitation he identifies is specific. On the one hand, he has achieved a useful tool, but he doesn’t know its internal workings in detail, which makes it difficult to diagnose potential problems and address its maintenance.
When to use vibe coding: prototypes and low-impact tasks.
Proofs of concept, prototypes, demonstrations, and one-off automations offer a context for experimentation. For example, presenting an idea for others to test or creating a small script that saves time on an occasional task.
The recommendation for those who want to start is to limit its use:
It’s fine for presenting an idea or testing if it makes sense. For automating everyday tasks that aren’t very important.
Vibe coding also presents an opportunity for non-developers, as “for non-technical profiles, it can help facilitate their tasks, with care.”
That care involves thinking about the consequences of a potential failure. A small application might handle sensitive information or perform an action that is difficult to undo. The project size guides the decision, but its use and impact also matter.
In low-risk contexts, vibe coding can facilitate experimentation and allow us to test solutions that we might not otherwise develop.
Limitations of vibe coding in scaled applications.
The scenario changes when a tool becomes part of a company’s operations. It must respond predictably, integrate with other systems, and allow modifications without each change compromising what already works.
Here lies one of the main objections: Scaled applications require a lot of stability because with scale, not only do benefits grow, but problems also multiply.
An inefficiency barely perceptible during a test can become a significant cost when repeated thousands of times. We illustrate this with a comparison. It’s not the same for a poorly optimized program to cost you cents in a proof of concept as it is for it to cost a client thousands of euros.
Dependencies and the number of people affected by a failure also grow. In this context, Gómez questions an approach based on generating code and correcting it until the result seemingly fits:
Vibe coding clashes with this, because its goal is not to think much about the code: generate quickly, see if everything seems to fit, and if not, then more vibe coding until it fits.
The comparison with code and fix —writing code and solving problems as they appear— helps contextualize this concern. The interest in developing complex software with more rigorous methods has a long history. The 1968 NATO conference on software engineering already addressed issues of design, production, testing, and maintenance.
The speed of code generation brings a familiar issue back to the table: how to ensure that software remains understandable and reliable as it evolves.
What to review before taking an application to production.
Reliability requires addressing various points throughout the process. Applications need a structure that facilitates their evolution and controls that help detect problems. As our Head of Frontend explains, they need to be well-structured, with clear code and several layers of protection, such as tests, code review, and monitoring.
Manual and automated tests allow for checking behaviors. Code review helps detect implementation issues. Shared standards make it easier for the team to maintain the solution, while monitoring allows observing how it responds when in use.
Added to this are automatic quality controls and limits agreed upon by the team. This entire process is a sum of layers at different parts of the software development process.
These measures must be adapted to the project and the industry. QA involvement is part of that work, along with the responsibility of those who develop and review the application. A successful test provides information; trust requires multiple checks and continuous monitoring.
From a week to an hour: the transformation of QA in a project
From experiment to production: where is the limit.
For those who want to start experimenting with vibe coding, we recommend choosing a specific, low-impact need. His position on how far to take this approach is clear: It’s fine for experiments, but not for production code.
This assessment refers to vibe coding understood as progressing without sufficiently understanding or reviewing what has been generated. It is compatible with using AI within a professional process that incorporates supervision, testing, and necessary controls.
Our main warning has to do with the total effort. Getting a first version quickly can shift work to subsequent phases. Because “this speed” is not free; it entails an increase in technical debt that will eventually have to be paid.
Vibe coding can be a good starting point for experimentation. Before turning that experiment into a tool that others depend on, it’s worth asking a question: do we understand what we’ve created well enough to maintain it and respond when it fails?
