Developers are increasingly relying on AI to generate code from natural language prompts—a practice known as vibe coding. This hands-off approach is creating a generation of developers who don't fully understand their own code. A couple of years ago, I wrote:
AI takeover won't be like Skynet, but it might still have the same effect. It'll start with small improvements to UX by suggesting what user wants. But as accuracy increases, users will get hooked & delegate all decision making to AI.
Still, I am surprised by how fast this has happened, and the fact that coding is one of the first domains affected. Just as companies once became locked into Oracle databases, unable to migrate away due to deep dependencies, today's startups risk becoming permanently dependent on AI code generators. But since the market has embraced the code generation path, we should at least take a more reasonable approach—write bad code first, then let AI refine it, instead of writing everything in English and losing our understanding of code.


The Problem with Vibe Coding

Vibe coding sounds great—just describe what you want, and AI writes the code. But over time, this leads to:
  • No understanding – You don't know how the code works, only the requirements you wrote in English. When something breaks, you're stuck debugging AI's work instead of your own, which often becomes more time-consuming than writing your own code from scratch.
  • No learning – If you never engage with code, what’s the difference between you and the end user? Why can’t the end user cut out the middleman (you) and do it themselves?
To be fair, vibe coding has its merits—non-technical founders can build MVPs and get their startups off the ground before hiring engineering talent. However, this initial convenience often comes at the cost of long-term technical debt and dependency.


Start with a Brittle Toy

Instead of vibe coding, writing brittle code to build an MVP is a much better option. Here’s an example: My 11-year-old son built a game called Flappy Snowman using Scratch. At first, he was comfortable with drag-and-drop blocks in Scratch. But as his game became popular, he realized it was too slow. He wanted to make it faster, so he decided to learn C# and rebuild it using the Unity game engine.
Now, imagine if AI could help him translate his Scratch project into Unity, step by step. Even with very little understanding of C#, he would still be able to grasp the code by mapping his Scratch blocks to corresponding C# logic. Through this process:
  • He can still understand his game’s logic because he started with something he built himself.
  • He can learn better coding practices by seeing how AI translates Scratch logic into C# logic.
  • He stays in control of the development, rather than outsourcing the thinking to AI.
This is the difference between bad code and vibe coding. One keeps developers engaged. The other turns them into passengers.


Grow it into a Dragon

Incidentally, this is how Mark Zuckerberg got started. He built Facebook using PHP, and once it took off, he hired brilliant engineers who developed HipHop Virtual Machine, which transpiles PHP into C++, significantly improving performance and scalability. This allowed Facebook to scale to billions of users. If a planetary-scale company can be built by a teenager using PHP, imagine what AI-based transpilers can do for young founders of the future.
Startup founders can rapidly prototype and launch MVPs while maintaining an understanding of their codebase, which is essential for future iterations and scaling. For learners and beginners, AI can serve as a bridge, helping translate simpler languages like Scratch or PHP into scalable backend solutions. This approach doesn’t force everyone to write optimized code from the start—it allows developers to begin with what they know and improve incrementally.


Summary

The Y2K crisis of the late 1990s was not just a bug fix—it birthed an entire industry. As companies scrambled to fix COBOL systems that couldn't handle the year 2000, Indian IT firms like TCS and Infosys stepped in. They started by fixing Y2K-related bugs, but in the process, they built expertise in maintaining and modernizing legacy systems. This led to long-term contracts, outsourcing deals, and eventually a shift from services to full-fledged product development. What began as “fixing bad code” evolved into a multi-billion-dollar industry that put India on the global tech map.
Now imagine if AI had existed then, automatically fixing every Y2K bug with a single prompt. No learning. No skill development. No transformation. Just a quick fix that left no lasting impact. That’s the choice we face today. We can use AI to paper over our limitations, or we can use it to enhance our capabilities. We can let it write our code, or we can let it teach us to write better code. We can become passive consumers of AI’s output, or we can remain active creators who use AI to push our boundaries. The code we write today shapes not just our software, but our future as creators.