Bolt, Replit, Lovable, and Cursor: Can AI Really Build Your Next App?

At this month's AI Tinkerers Club, we explored "Code for non-coders"—a topic that's changing how software gets built.

I've spent dozens of hours diving deep into this space, testing various tools, and even using Cursor AI to build the very site you're reading. What I discovered might surprise you.

Rather than focusing on specific tool features (which would be outdated by tomorrow), I'll share the big picture principles that will remain relevant regardless of which tools you choose.

Let's explore how AI is transforming coding, what's possible today, and most importantly—where you'll still hit the wall.

The Evolution of AI Coding

AI's role in software development has transformed dramatically in just a few years:

Before Gen AI (pre-2022)

Coding was entirely manual with limited assistance. IDEs provided basic help like autocomplete based on predefined rules and syntax analysis. Tools like VS Code's IntelliSense could suggest variable names or methods, but couldn't understand context or generate meaningful code.

Stage 1: AI Assistants (2022-2023)

GitHub Copilot marked the beginning of genuine AI assistance for coding. These assistants could:

• Generate relevant code based on comments or context
• Answer natural language questions in chat interfaces
• Suggest entire functions or code blocks that aligned with your intent

The key breakthrough? These tools understood context and could generate meaningful, relevant code—not just auto-complete based on syntax rules.

Stage 2: AI Agents (Current)

We've now entered the era of "Agents"—AI systems that handle entire workflows autonomously:

• They design their own execution plans
• Access multiple tools (code editors, documentation, deployment platforms)
• Allow human review at key decision points

Replit Agent and Cursor's Composer are some of the tools that illustrate this approach.

What's Next?

The future promises even more seamless human-AI collaboration:

• Real-time adaptation to your coding activity and project context
• Proactive suggestions and background code generation
• Fluid integration across your entire development workflow

The boundary between human and AI contributions will continue to blur—but we're not quite there yet. The question remains: how far can these tools push the wall of AI incompetence?

Why AI Excels at Coding

There are three fundamental reasons why coding has become one of AI's strongest domains:

1. Vast, High-Quality Training Data

AI models have ingested thousands (if not millions) of repositories containing:

• Code samples for virtually every common programming task
• Documentation from all major frameworks and libraries
• Solutions to standard problems across diverse domains

Note: The copyright implications of this training data remain controversial and may present legal risks for commercial use.

Note: This cool card is from the AI Tinkerers Card future ethics expansion.

2. Code is Highly Structured

Programming languages offer ideal prediction environments for AI:

• Formal syntax with strict rules
• Clearly defined patterns (conditionals, loops, functions)
• Standardized libraries and frameworks
• Recurring architectural patterns

This structure makes it easier for Large Language Models (LLMs) to predict the output of code.

3. Built-in Verification Systems

Code provides clear feedback mechanisms that enhance AI learning:

• Programs either run or they don't—binary success criteria
• Error messages with specific debugging information
• Stack traces pinpointing exact failure locations
• Automated tests validating correct behavior

These properties make coding an ideal domain for reasoning engines and autonomous agents that can verify their own outputs and adapt their plan accordingly.

The AI Coding Spectrum: From No-Code to Co-Code

The landscape of AI-powered development tools spans three major categories, each serving different skill levels and needs:

No-Code (Point & Click): Webflow, Wix, Framer, Builder.io

The promise: Build sophisticated websites and applications using visual interfaces without writing a single line of code.

Traditional no-code platforms have now integrated AI to accelerate your building process:

• Design suggestions based on your content
• Component recommendations to improve functionality
• Automated content generation and optimization

Notable platforms:

• Webflow, Wix, and Framer for websites
• Bubble and Adalo for applications
• Builder.io for design-focused solutions

Low-Code with Agentic App Builders: Bolt, Lovable, V0, Replit

The promise: Create functional applications with minimal coding knowledge by letting AI handle the technical implementation.

🔥 This category is on fire! You'll find all the new kids on the block:

• Lovable,
• Replit from Stackblitz,
• V0 from Vercel,
• Bolt

At the core, an AI Agent that can (in theory) generate entire applications from natural language descriptions:

• AI agents plan and build complete apps from simple prompts
• Iterative refinement through conversational interfaces
• Integrated backends with database and authentication Lovable and Bolt include Supabase; Lovable adds Stripe and a few others)
• One-click deployment without infrastructure management

Do These Tools Deliver?

For simple applications—absolutely. You can build functional prototypes and basic apps with surprising speed.

However, you'll inevitably hit the wall of AI incompetence when attempting anything moderately complex. Even with my technical background, I found myself frustrated by these limitations during testing.

Which Agentic App Builder Stands Out?

After extensive testing and feedback from AI Tinkerers Club members, Lovable emerges as the current favorite for several compelling reasons:

• Clean, intuitive interface that doesn't overwhelm beginners
• Robust (well more or less) integrations (Supabase for database/auth and Stripe for payments)
• Innovative "visual edits" feature bridging the no-code/low-code gap

If you're diving into AI-powered development for the first time, Lovable offers an excellent entry point. (No affiliate relationship—just sharing what's working best right now.)

It's not ideal if you want granular code control—in that case, consider Replit or move to the co-code category.

Bonus: AI Widget Builders in Your Everyday Assistant

Your familiar AI assistants can also create interactive mini-applications:

• ChatGPT + Canvas: Build and test interactive widgets within the chat interface
• Claude + Artifacts: Create shareable, deployable components

These capabilities preview what might eventually evolve into full application builders within general-purpose AI assistants.

LAST MINUTE NOTE - Claude Code

Claude just released Claude Code, an AI Agent that you can use from the terminal. Yet another Agentic approach to coding. From the demo, the Agent seems pretty capable at exploring codebases and suggesting changes. Can't wait to try it out!

Co-Code with Agentic Code Editors: Cursor, Windsurf

The promise: Supercharge your development workflow with AI assistance while maintaining complete control over your code.

This category fits my personal workflow perfectly—I understand programming fundamentals but don't code daily, so the AI is total enabler.

Key players include:

• VS Code + Github Copilot
• Cursor
• Windsurf

These tools currently fall into two subcategories:

Cursor has dramatically expanded my development capabilities—I'm shipping features faster and tackling complexity I would have avoided before. The agent-based features are particularly powerful for refactoring, implementing new features, and debugging complex issues.

Convergence on the Horizon

The boundaries between these categories are rapidly blurring. Replit offers a capable editor that bridges low-code and co-code approaches, while Cursor's increasingly powerful agent capabilities are making it viable for some low-code workflows. Expect continued convergence as these tools evolve.

Finding Your Sweet Spot: Matching Tools to Project Types

While you'll occasionally hear stories of someone building complex applications with low-code tools, these are exceptions rather than the rule. Here's a realistic assessment of which tool category best fits different project types:

No-Code (Point & Click)

Ideal for: Visual-focused websites with minimal custom functionality

• Marketing and landing pages: Create visually impressive, conversion-focused sites with animations and interactive elements
• Portfolio and business websites: Professional online presence with standard components like contact forms, galleries, and basic content management
• Simple e-commerce: Basic storefronts with standard product catalogs and checkout flows

AI primarily enhances these tools through design suggestions, content generation, and layout optimization rather than complex functionality.

Low-Code with Agentic App Builders

Ideal for: Functional applications with well-defined boundaries and standard patterns

• Interactive tools: Calculators, converters, analyzers, and visualization widgets
• Content-focused applications: Blogs, knowledge bases, and content repositories with basic interactive features
• Proof-of-concept prototypes: Quickly validate ideas before investing in full development
• Simple CRUD applications: Basic data entry and display with limited business logic

The key is keeping your application "simple"—which I'll help you define more concretely in the next section.

Co-Code with Agentic Code Editors

Ideal for: Development teams and individuals with programming knowledge seeking acceleration

• Full-spectrum development: From simple utilities to complex enterprise applications
• Custom integrations: Projects requiring connection to multiple external systems
• Performance-critical applications: Systems where optimization matters
• Unique business logic: Applications with non-standard workflows or algorithms
• Extending low-code projects: Taking over when you hit the limitations of low-code tools

The primary advantage is maintaining complete control while leveraging AI as a productivity multiplier. You're not constrained by what the AI can generate in a single prompt—you can iteratively refine and extend with AI as your collaborative partner.

The Convergence Zone

As these approaches increasingly overlap, the key differentiating factor becomes how much direct control you need over the code. If you're comfortable delegating most technical decisions to AI, low-code tools may suffice. For complex projects requiring precise implementation or non-standard patterns, co-code remains essential.

Where's the Wall? The Current Limits of AI Coding

Despite impressive capabilities, there are clear boundaries to what today's AI coding tools can accomplish—what I call "the wall of AI incompetence." Understanding these limitations helps set realistic expectations.

Signs You've Hit the Wall

You'll recognize these frustrating patterns when your AI tool reaches its limits:

1. The Circular Bug Cycle: The AI fixes one issue only to introduce another, then fixes that but breaks something else. This creates an endless loop where you never reach a stable working state.
2. Solution Stagnation: The AI repeatedly proposes the same non-working solutions despite your feedback. It either fails to understand the core problem or lacks the capability to solve it correctly.
3. Context Collapse: As your project grows more complex, the AI loses track of how components interrelate, suggesting changes that break existing functionality or contradict earlier design decisions.

Guiding the AI Effectively

The key insight: AI coding tools aren't autonomous developers—they're assistants requiring human guidance. Your ability to provide that guidance depends on your skills:

Without Coding Knowledge:

You can guide AI as a:

• Project Manager: Create clear requirements, decompose complex features into smaller tasks, and maintain focus on core functionality.
• Product Owner: Develop detailed user stories and acceptance criteria, emphasizing what the application should accomplish rather than implementation details.
• QA Tester: Thoroughly test AI-generated code, providing specific error descriptions and reproduction steps rather than vague problem statements.

The testing role is particularly crucial—without technical knowledge, your best chance of navigating past the wall is through detailed, specific feedback about exactly what isn't working.

With Coding Knowledge:

You can provide much more sophisticated guidance as an:

• Architect: Define the overall application structure, select appropriate technologies, and establish patterns for component interaction.
• Lead Developer: Review code critically, identify potential issues proactively, and provide specific technical direction when the AI struggles.
• Debugging Partner: Use your technical understanding to interpret errors, identify root causes, and guide the AI toward effective solutions.

The more technical knowledge you possess, the further you can push the wall. Without coding knowledge, you'll hit limitations sooner, particularly when building anything beyond basic applications.

Remember: AI coding tools are powerful accelerators, not replacements for human judgment. They're most effective when viewed as collaborative partners that amplify your capabilities rather than autonomous developers.

Assessing Your Project's Complexity

Before committing to an AI-powered development approach, evaluate these key factors to realistically gauge your project's complexity:

For each dimension that trends toward "Complex," you significantly increase the likelihood of hitting the AI competence wall when using low-code tools. Projects combining multiple complex requirements almost certainly require coding knowledge and co-code approaches.

Strategic Recommendations for Success

After extensive experimentation with AI coding tools, here are my practical recommendations for non-coders looking to build with AI:

Start Small and Focused

Begin with a clearly defined, limited-scope project rather than an ambitious platform. Success with smaller projects builds both confidence and skills that transfer to larger undertakings.

Ideal first projects include:

• A personal portfolio site
• A simple tool that solves one specific problem
• A content-focused application in a domain you understand deeply

Develop Wall Recognition Skills

Learn to identify when you've hit the AI's limitations to avoid wasting time and resources:

• When bug fixes create cyclical problems
• When the AI repeatedly suggests similar non-working solutions
• When complexity seems to increase exponentially with each new feature

When you hit the wall, consider either simplifying your requirements or engaging technical help rather than fighting the same issues for days (and spending needlessly on AI usage charges).

Master the Art of Effective Prompting

Without coding skills, excellent prompting becomes your superpower:

• Focused: Clearly define what you want to achieve with concrete examples
• Dense: Provide relevant background information and constraints
• Guiding: Include all necessary specifications, including visual requirements and report issues with precise steps to reproduce and expected outcomes

Consider Strategic Skill Development

While AI can help non-coders build applications, building your own skills pays enormous dividends:

• Learn fundamental programming concepts (variables, functions, data structures)
• Understand basic web technologies (HTML, CSS, JavaScript fundamentals)
• Familiarize yourself with system architecture concepts (frontend, backend, databases)

Even modest technical knowledge dramatically increases your ability to guide AI tools effectively and troubleshoot when they struggle.

Alternatively, partner with someone who has complementary technical skills or... wait for AI capabilities to improve further! Who knows, maybe you'll be able to build with AI in your sleep by then!

Conclusion: The New Era of AI-Powered Development

I believe AI coding tools are democratizing software development in unprecedented ways, but... They're not magic solutions!

In the same way that AI won't make you a Pulitzer prize winning author, it won't make you a master coder. As with any AI use case, the most successful builders will combine AI capabilities with their own skills, ideas and creativity.

If you manage to effectively collaborate with AI, and you target the right level of complexity, you'll be able to build some amazing things.

So... What will you build?

Appendix: Related cards from the AI Tinkerers' Card Deck

You can imagine a lot of activities to learn about AI coding capabilities for your next training and workshops. Here are some of the most relevant cards on that topic. Learn more about the cards here.