Vibe Coding is a Beautiful Lie (Unless You Know How to Catch the Fall)
The current state of artificial intelligence presents a difficult challenge for the industry. There is a strong push to deploy autonomous agents that can manage our digital activities without human oversight. These tools are promoted as the best way to gain efficiency. They claim to organize inboxes, book appointments, and generate code independently. However, recent incidents reveal significant risks in this rapid adoption. We have seen cases where automated systems deleted critical data or allowed unauthorized access to user accounts. These failures demonstrate that speed should not compromise safety and security. The desire for quick results often makes us overlook the fundamental principles of software engineering. We must ensure that innovation does not compromise the stability of the systems we rely on.
My journey began in 2009, long before the current hype cycle took hold. I started by building desktop applications for Windows, where every line of code had to be precise because the environment was controlled and predictable. Over the years, I transitioned to web applications, then mobile, and eventually to the complex world of microservices and cloud-native architectures. Each shift brought new challenges, but the core requirement remained the same, reliability. In those early days, a mistake in a database script could corrupt years of data, and the recovery process was painful and slow. I recall writing custom scripts to clean up malformed records in a legacy system from the 1990s. The schema was rigid and unchangeable, and a colleague repeatedly inserted incorrect data. My script had to be surgical, checking every record before making a change. If I had rushed that process or relied on a tool that did not understand the context, the entire system could have collapsed.
Today, the industry faces a similar risk but on a much larger scale. The trend of "vibe coding" encourages developers to prompt AI models to generate code without understanding the underlying logic. This approach treats software engineering as a black box where the output matters more than the process. While this method can produce results quickly, it creates a dangerous illusion of competence. When an AI generates a function that interacts with a critical payment gateway or a user database, the developer must still possess the knowledge to verify its correctness. Without this understanding, we are essentially handing the keys to the kingdom to an entity that does not comprehend the consequences of its actions. The recent story of a safety lead whose inbox was wiped clean by an AI agent illustrates this perfectly. The agent followed its instructions literally, interpreting "clean" as "delete everything," because it lacked the human judgment to understand the nuance of the request.
The solution to this crisis is not to abandon AI, but to integrate it with the rigorous standards of traditional software engineering. We must remember that speed is a business requirement, but it cannot come at the cost of stability. The industry has spent decades developing best practices to prevent small changes from breaking critical legacy systems.
We must remember that speed is a business requirement, but it cannot come at the cost of stability.
These practices include thorough testing, code reviews, and a deep understanding of the system architecture. When we introduce AI into this workflow, these safeguards become even more important, not less. An AI can write a function, but a human engineer must review it, test it, and ensure it aligns with the broader system goals. The danger lies in assuming that the AI knows better than the experienced engineer.
In my view, the years of experience in software development are the most valuable asset we have in this new era. Experience teaches us to anticipate failure modes that are not obvious on the surface. It teaches us that a system is only as strong as its weakest link, and that link is often the assumption that a tool will behave exactly as intended. In a recent blog post I wrote argue that this deep institutional knowledge is the secret weapon against the unpredictability of AI. It is the ability to look at a generated piece of code and immediately spot the logical flaw that an AI might miss. It is the intuition to know when a script is about to go too far.
As we move forward, the role of the engineer will evolve, but the need for human oversight will never disappear. We must resist the pressure to adopt tools blindly and instead demand transparency and control. The future of AI in software development depends on our ability to balance innovation with responsibility. We can embrace the speed that AI offers, but we must do so with the wisdom of those who have seen systems fail before. The goal is not to replace the engineer, but to empower them with tools that amplify their expertise rather than bypass it. If we forget the lessons of the past, we risk repeating the mistakes of the present on a scale that could be catastrophic. The path forward requires a commitment to the fundamentals, ensuring that every line of code, whether written by a human or an AI, stands on a foundation of solid engineering principles.
