Vibe Coding: When to Trust the AI, and When to Take the Wheel
How Cursor and Lovable are reshaping software creation and what it means for your workflow
In a previous newsletters, I shared my experience of building three apps in just two months after a 4-year coding hiatus, all thanks to AI-powered development tools like Cursor. The response was overwhelming - many of you reached out to share similar experiences or ask questions about this new approach to software development.
What I was doing, without fully realizing it, was participating in what's now being called "vibe coding" - a term that gained popularity when AI researcher Andrej Karpathy quipped about "fully giving in to the vibes... and forget code even exists." This approach transforms programming from writing line-by-line code into a natural language conversation with AI.
Today, I want to go deeper into this trend that's reshaping how software gets built, who can build it, and what skills truly matter in the AI era. What does this shift mean for developers, teams, and the future of coding itself?
The Vibe Coding Revolution
The core concept of vibe coding is simple yet transformative: instead of writing code directly, you describe what you want in plain language, and AI tools generate the implementation for you. You become less of a traditional programmer and more of a director, guiding the AI toward your vision.
The hype around vibe coding is huge already. Tools like Cursor have exploded in popularity, reaching an estimated 360,000 users and $100M ARR within just a year of launch. Meanwhile, Lovable - another vibe coding platform - amassed over 30,000 paying customers in just three months, with users creating more than 1.2 million apps.
The workflows emerging around these tools are fascinating:
Rather than starting with boilerplate code, developers begin with a natural language specification
Instead of writing functions line by line, they ask for features like "add a user login system" or "create an analytics dashboard"
Rather than spending hours debugging, they can highlight problematic code and say "fix this issue"
For experienced developers, this means less time on tedious tasks and more focus on architecture and problem-solving. For newcomers, it lowers the barrier to entry dramatically. It's no wonder these tools are being adopted so rapidly.
Democratizing Development
Perhaps the most exciting aspect of vibe coding is how it's expanding who can build software. In my previous newsletter, I mentioned how I was able to jump back into development after years away - but the implications go much further.
Product designers can now skip high-fidelity mockups and build interactive prototypes directly. Entrepreneurs can launch MVPs without hiring an engineering team. Analysts can create data tools without deep programming knowledge.
This democratization is powerful. Software has eaten the world, but until now, only a small percentage of people could create it. Vibe coding is changing that equation, giving more people the ability to bring their ideas to life.
The Evolving Role of Professional Developers
Rather than making developers obsolete (a common fear), the rise of AI is creating two distinct tracks in software development: casual "vibe coding" for rapid creation and AI-enhanced professional development for complex, production-grade systems.
Casual Vibe Coding
This approach, which I used for my side projects mentioned earlier, excels in contexts where speed and iteration trump architectural perfection:
Quick prototypes and MVPs
Personal projects and tools
Simple applications with limited scope
Learning environments and experiments
The focus here is on rapid results—getting something functional that can validate ideas, demonstrate concepts, or solve immediate problems without the overhead of traditional development processes.
AI-Enhanced Software Development
For enterprise applications, critical systems, and production environments, a different paradigm is emerging. Professional developers are integrating AI into more rigorous workflows where they become:
System architects who define software structure that AI fills in
Prompt engineers who precisely articulate requirements for the AI
Quality guardians who rigorously validate AI-generated code through testing and code review
Technical directors who guide AI through complex problems while maintaining overall vision
Integration specialists who connect AI-generated components into robust systems
In these professional settings, AI isn't replacing software engineering disciplines - it's augmenting them. Version control, code reviews, performance testing, and security practices remain essential, but they're now complemented by AI capabilities.
Some development teams are establishing formal patterns: using AI for the first draft of code, pair programming with it on complex problems, or delegating specific components while maintaining human oversight on critical paths. It's a more structured approach that treats AI as a powerful team member rather than a replacement for human expertise.
This evolution reminds me how computers transformed mathematics—they didn't replace mathematicians but revolutionized their workflow, enabling them to tackle previously impossible problems. Similarly, AI tools are liberating professional developers from boilerplate code, allowing them to focus on the creative and strategic aspects of software creation.
The Pitfalls: What We're Learning
As the saying goes, with great power comes great responsibility, and vibe coding exemplifies this perfectly. Here are a few pitfalls you need to be aware of when vibe coding:
1. The Learning Paradox
A quick online review of vibe coding experiences reveals several cautionary tales: developers losing months of work due to missing version control, exposed databases compromising user data, and security vulnerabilities arising from incomplete understanding of best practices. These incidents underscore the importance of maintaining fundamental development practices even while embracing AI assistance.
This highlights what I call "The Learning Paradox" of AI-assisted development: the same tools that make coding more accessible can inadvertently short-circuit essential learning. When AI handles the difficult parts, developers might skip building the foundational knowledge they'll need when things go wrong.
Traditional learning paths followed a logical progression: master simple queries before complex ones, understand basic data structures before advanced algorithms. Each step built on the last, creating a solid foundation of knowledge. But AI tools can generate complex code without requiring you to understand the fundamentals first—like giving someone advanced calculus solutions without teaching basic arithmetic.
This doesn't mean we should avoid these tools, but rather that we need to be intentional about skill development. The developer who lost months of work might not have made that mistake had they learned coding through the traditional, sometimes frustrating path that emphasizes fundamentals like version control from day one.
2. Quality and Maintainability Concerns
AI-generated code often works on the surface but may have hidden issues:
Over-engineered solutions with unnecessary complexity
Subtle bugs that only appear in edge cases
Security vulnerabilities that aren't immediately obvious
Poor performance optimization
Difficulty maintaining code whose rationale isn't clear
I've experienced this firsthand. Recently, while building a feature using Cursor, the AI suggested an elegant-looking solution that actually circumvented the authentication system. If I hadn't been testing thoroughly, this would have caused problems down the line.
3. Versioning and Auditability Challenges
Traditional development practices need adaptation in the vibe coding era:
How do you track which parts of code came from your intent versus the AI's inference?
When a bug is found months later, how do you trace back through AI-generated code?
What about licensing issues when AI potentially incorporates open-source snippets?
These aren't insurmountable problems, but they require new approaches. Some developers have started logging prompts as part of their documentation, creating an audit trail that explains why code was written a certain way.
Moving Forward: Finding Your Sweet Spot
After several months working with these tools, I've discovered that success lies in finding the right balance between AI assistance and engineering discipline.
When to Vibe and When to Engineer
For getting started, exploring ideas, and building MVPs, vibe coding is revolutionary. I can transform concepts into working prototypes in hours instead of days, testing assumptions and gathering feedback with unprecedented speed.
However, as projects mature toward production, traditional software engineering skills become increasingly vital. Production-ready code requires robust error handling, performance optimization, security considerations, and maintainable architecture that AI alone cannot (yet) provide.
What This Means for You
For professional developers: Embrace AI for rapid prototyping and mundane tasks, but maintain your expertise in system architecture and fundamentals. Your value increasingly lies in the areas AI struggles with—making critical design decisions, ensuring security, and architecting scalable systems.
For newcomers: These tools can help you build projects that once seemed out of reach, but invest time learning the fundamentals alongside your AI experiments. The developer who lost months of work illustrates why understanding basics like version control remains essential.
For teams: Consider how these tools might reshape your workflows. Could designers prototype directly? Might PMs implement simple features themselves? Then establish guidelines for when projects transition from "vibe mode" to more rigorous engineering practices.
The future isn't about AI replacing human expertise—it's about finding the right partnership where AI handles the tedious parts while humans focus on creativity, judgment, and the deeper aspects of software engineering that truly require our unique capabilities.
Final Thoughts
The vibe coding movement represents a profound shift in how software is created - blending human creativity with AI capabilities in ways that were science fiction just a few years ago. While it comes with challenges, the potential benefits for productivity, creativity, and accessibility are too significant to ignore.
As I continue my journey with these tools, I've learned that they don't replace the need to understand fundamental software principles - they amplify what you already know and can do. The future isn't about AI replacing human effort - it's about a new kind of partnership where each side brings unique strengths to the table.
I'd love to hear about your experiences with vibe coding tools. Have you tried Cursor, Lovable, Bolt or similar platforms? What successes or challenges have you encountered?