I’ve been vibecoding for over a year. People keep telling me I’m using the wrong tools. So I did a deep dive — with Claude Code as my research partner — and here’s what I actually found.
I’m a non-technical founder. I don’t write code. I don’t read code particularly fluently either. What I do is describe what I want — in plain English, sometimes with hand-drawn wireframes, sometimes with nothing more than a paragraph — and AI builds it for me. That process has a name now: vibecoding. And I’ve been doing it for over a year.
My stack has been remarkably stable for someone operating in one of the fastest-moving spaces in tech. Lovable generates the applications. Claude Code handles the complex stuff — debugging, multi-file changes, architectural decisions, the things Lovable can’t do on its own. GitHub stores everything and manages deployment. Three tools. That’s it.
This combination has let me build real products for real clients. Web applications, dashboards, internal tools, assessment platforms. Things that would have cost tens of thousands of dollars in developer fees, built in days instead of months. I’m not exaggerating for effect — that’s genuinely what happened.
But if you spend any time in the vibecoding community, you know there’s a constant background hum: “You need to try [X].” Every week there’s a new tool, a new platform, a new thing that’s supposedly going to make everything else obsolete. The FOMO is relentless.
Lately, the loudest voice has been about Google Antigravity. If you’re in any founder community, any vibecoding Discord, any X thread about building with AI, you’ve heard it. “Have you tried Antigravity?” “Lovable can’t do enterprise.” “Antigravity is the future of development.” It went from whisper to drumbeat to full-on chorus in about three weeks.
Meanwhile, Cursor has its own devoted following. Developers — actual, professional developers — who insist it’s the only serious tool for AI-assisted coding. Every conversation about tooling eventually includes someone saying, “But are you using Cursor?” as if the answer to that question determines whether you’re a real builder or just playing around.
And then there's the native app question. Clients don't always want web apps. Some of them specifically want App Store presence - push notifications, biometric login, that "download the app" credibility. My current stack only produces web applications. I've felt that gap widening.
So I did what I always do when I'm uncertain: I went deep. I spent time researching every tool people were pushing at me, reading documentation, watching demos, and digging into what's actually possible. And because I have an unusual advantage - Claude Code isn't just my coding tool, it's also my research partner and, frankly, my most trusted oracle on all things technical - I was able to go deeper than most non-technical founders would. What follows is what I actually found - and what I'm planning to test hands-on over the next month.
Antigravity is Google’s new AI-powered development environment. Think VS Code, but rebuilt from the ground up around AI agents. It launched in November 2025 and it’s currently free — which is part of why adoption has been so explosive.
The concept is genuinely exciting. Instead of telling AI what code to write (like Cursor) or describing an app you want (like Lovable), you become a “Mission Controller.” You define missions — goals, essentially — and AI agents plan, code, test, and verify autonomously. Multiple agents can work in parallel on different parts of a project. It feels less like using a tool and more like managing a team.
It supports Gemini 3 Pro, Claude, and some open-source models. The agent-first approach means it can generate what they call “Artifacts” — screenshots, recordings, task lists — so you can verify the work without reading code. For someone like me, who doesn’t read code fluently, that’s a genuinely appealing proposition. The idea of reviewing screenshots instead of staring at syntax is compelling.
The hype is real. Indie hackers on X ranked it in the top three tools alongside Lovable and Cursor. The community is growing fast. The agent-first paradigm does feel like it could be the future of how non-technical people interact with software development.
But here’s where the hype collides with reality.
Let that sink in. This isn’t a theoretical risk discovered in a lab. Within a single day of real-world usage, researchers identified ways that malicious prompts could steal data from your development environment and execute arbitrary code on your machine. And one person lost everything on their hard drive.
The consistent recommendation from security researchers has been unambiguous: use Antigravity only in sandboxed environments. Never point it at production credentials. Never use it with client data. Never run it on a machine that has access to anything you can’t afford to lose.
For a consultancy like mine — where I’m handling client projects, proprietary business logic, and sometimes sensitive data — that’s a dealbreaker for production use. I can’t tell a client their application was built in an environment where a prompt injection could have exfiltrated their data. That’s not a conversation I ever want to have.
So here’s where I landed: Antigravity as an exploration tool? Absolutely. As an “idea factory” where I test concepts in a sandboxed environment before building them properly in Lovable? Yes, I think that’s genuinely valuable. As a production environment for client work? Not today. Maybe not for a while.
Cursor is designed for experienced developers. It’s a code editor — a very good one — with AI deeply integrated into the editing experience. But it assumes you understand code syntax, project structures, debugging workflows, and the fundamentals of software engineering. It makes developers faster. It doesn’t make non-developers into developers.
For someone like me, Cursor would add friction, not remove it. I’d be looking at code I don’t fully understand in an interface designed for people who do. Claude Code gives me everything Cursor would, but through natural conversation instead of an IDE. I describe what I want. It builds it. We talk through problems. That’s my workflow, and Cursor doesn’t improve it.
My honest take: if you’re already a developer, Cursor is exceptional — probably the best AI-augmented coding experience available right now. If you’re a non-technical founder, skip it. It’s not designed for how we work. One thing worth noting for enterprise context: Cursor is SOC 2 certified, which matters if your clients care about compliance. But that alone doesn’t make it the right tool for everyone.
Here's a gap nobody in the Lovable community talks about enough: Lovable builds web apps. Beautiful, functional, genuinely impressive web apps. But they're not native iOS or Android apps. They can't go to the App Store. You can add them to a home screen as a PWA, but that's not the same thing and clients know it.
For a lot of use cases, that's fine. A well-built web app works on every device, needs no installation, and updates instantly. But some clients specifically want App Store presence - push notifications that actually work, biometric login, in-app purchases, that "real app" legitimacy. I've had to turn down work because of this gap.
So I researched the options. I haven't tried any of these yet - but the research is promising, and these are the tools I'm planning to explore over the next month.
This is the finding I'm most excited about. Despia claims to wrap Lovable web apps as real native apps - push notifications, biometrics, in-app purchases, App Store deployment. One-click publishing. If it works as advertised, I wouldn't need to learn a new tool or change my workflow. I'd keep building in Lovable exactly as I do now, and Despia would handle the native layer. This is top of my list to test.
Think "Lovable for mobile." Same natural language prompting approach, but it outputs React Native apps - truly native, not wrapped web views. Backed by a16z, $19/month. From what I've read, Rork looks like it could be the right choice when a client needs a native-first app built from scratch rather than wrapping an existing web app. I'm planning to build something small with it to test the workflow.
The most enterprise-ready option on paper, but it's a visual builder, not a natural language tool. Steeper learning curve. You're dragging and dropping components, not describing what you want in English. I'm keeping FlutterFlow in reserve for when a client specifically needs Flutter - not rushing to learn it until I have to.
Can do web and mobile, but from what I've seen in demos and documentation, it doesn't seem to do either as well as the dedicated tools. It's a generalist in a space where specialists win. The existing tools in my stack already appear to cover everything Bolt offers - but I'll reserve final judgement until I've actually used it.
Here's where I've landed after weeks of research and honest conversation with Claude Code. Not a comparison matrix. Not a scorecard. Just a clear statement of what I'm using, what I'm going to test, and what I'm watching.
Lovable + Claude Code + GitHub. This hasn't changed. Lovable for generation, Claude Code for the hard stuff, GitHub for version control and deployment. It works. I'm fast with it. I know its limits.
Lovable + Despia for wrapping existing web apps into real native apps. Rork for native-first builds when wrapping won't cut it. I haven't tried either yet, but both use the same natural language prompting workflow I already know - which is why they're top of my list.
Antigravity. Free, powerful, sandboxed only. My idea factory, not my production environment. I use it to test concepts before committing to building them properly.
I'm watching, not switching. Cursor when I can read code fluently. FlutterFlow when a client specifically needs Flutter. OpenAI's agent tools when they mature. The best time to adopt a new tool is when you hit a real wall - not when Twitter tells you to.
| Purpose | Tool | Status |
|---|---|---|
| Web apps | Lovable + Claude Code | My daily stack |
| Complex features | Claude Code (terminal) | My power tool |
| Native apps (existing) | Lovable + Despia | To test next |
| Native apps (new) | Rork | To test next |
| Exploration | Antigravity (sandboxed) | Playing with |
| Production IDE | Cursor | Not yet |
| Enterprise mobile | FlutterFlow | In reserve |
Over the next month, I'm going to take one of my existing Lovable projects and try to deploy it to the App Store with Despia. That will tell me more than any amount of research ever could. There's a difference between understanding something conceptually and actually shipping it, and I want to close that gap.
I'm also going to build something small in Rork - probably a simple internal tool - to test the native-first workflow end to end. I want to know whether the natural language prompting approach translates as well to mobile as it does to web. The research suggests it should, but research is cheap. Shipped products are what matter.
And I'm going to keep using Antigravity as a sandbox, because the agent-first concept is genuinely exciting even if it's not production-ready. The idea of defining missions instead of writing prompts feels like the direction everything is heading. I just need it to get there without eating my hard drive first.
The vibecoding space moves fast. What I've written here will probably need updating in three months. Tools that don't exist today will be on everyone's lips by summer. Platforms I've dismissed will ship the feature that changes my mind. That's the nature of this space, and honestly, it's part of what makes it exciting.
But that speed is also what makes discipline important. If you're a non-technical founder feeling the pressure to chase every new tool: stop. Pick the stack that works for you today, get good at it, learn its limits, and add tools only when you hit a real wall. Not when someone on X tells you to. Not when a new launch gets 10,000 upvotes on Product Hunt. When you hit a wall that your current tools can't get you past.
I'll report back when I've actually tested these tools. Watch this space.
If you're building with AI tools and want to compare notes, I'm always open to a conversation.
Get in touch