A Deep Dive into AI Coding Assistants: Lovable, Bolt.new, Cline, and Cursor/Windsurf
Introduction
Building applications with the help of AI coding assistants is becoming more common, and the range of tools available is expanding rapidly. Recently, I’ve experimented with four different approaches—Lovable, Bolt.new, Cline (agent mode), and Cursor/Windsurf (in both agentic and non-agentic modes)—to create a Pomodoro-style productivity application guided by a Product Requirements Document (PRD). In this post, I’ll share my firsthand experiences, highlight their strengths and weaknesses, and offer a recommended workflow to get the most out of these tools.
The Experiment Setup
The PRD Origin:
I started with a detailed PRD generated using OpenAI O1, which outlined requirements for a Pomodoro productivity app. I aimed to see how each coding assistant handled the same starting document. Ideally, the assistants would take the PRD as input, build out the initial features, and then refine and customize the application as needed.
Tools Tested:
Cline (Agentic Mode, Claude 3.5)
Cursor/Windsurf (Sonnet 3.5 - tested in both agentic and non-agentic modes)
Other Auto-Coding Assistants Worth Mentioning
exploring. From GitHub Copilot’s deep IDE integration to Amazon CodeWhisperer’s cloud-native support, each tool brings unique strengths to the table. Notable mentions include AWS CodeWhisperer, Tabnine, Replit Ghostwriter, Microsoft Azure OpenAI Services, and V0 by Vercel.
Key Criteria:
Fidelity to the PRD
Ability to bootstrap the application
Handling incremental refinements and customizations (downstream tasks)
Documentation quality
Cost-effectiveness and ease of iteration
Initial Observations
Lovable and Bolt.new (Click on the link to see deployed code)
Pros:
Both Lovable and Bolt.new were effective for initial scaffolding. They got the bare-bones application up and running quickly, providing a solid foundation well aligned with the PRD.
Lovable’s output looked more polished, pushing the customization path further, including starting some preference interfaces.
Cons:
Neither Lovable nor Bolt.new excelled at implementing more complex downstream tasks beyond the basic design phase. They seemed to struggle once requirements moved from high-level UI design to more intricate logic.
One of the great strengths of these platforms is the straightforward nature of non-developers, as seen by the development and deployment all in one. Other systems require a knowledge of deploying locally and to a remote server.
Check out the deployed app on vercel here: https://pomodorov2-cline.vercel.app/
Pros:
Cline started strong: it provided thorough, high-quality documentation upfront. This set it apart because it established a strong conceptual foundation before diving into coding tasks.
When Cline worked well, it integrated features, handled updates, and even ran tests in real-time, thanks to its agentic capabilities. Simulating a browser environment and testing on the fly was impressive and time-saving—at least in theory.
Cons:
As I pushed Cline to update timer interfaces and integrate certain custom preferences, it “came off the rails.” The assistant struggled to follow through on incremental changes, leading to confusion and tangential code modifications that did not align with the PRD.
At one point, Cline’s agentic mode performed a misguided checkpoint action and deleted about 30 changes, breaking the application. It wasn’t intuitive how to rebuild the project once it had been derailed.
These mistakes cost me about $50 in usage fees—Cline’s agentic forays can be expensive experiments if not carefully managed.
Check out the cool agent in action:
It can even launch a site review in a browser using Claude computer use!
And fixes its own errors:
Make sure to only auto-accept for a limited number of iterations:
Cursor/Windsurf (Agentic and Non-Agentic Modes):
Check out the deployed app on vercel here: https://pomodorov2-cursor.vercel.app/
Pros:
Cursor/Windsurf, when run in a non-agentic mode, provided a stable environment for incremental feature builds. After using Lovable or Bolt.new for initial scaffolding, I could “check out” the code into Cursor/Windsurf to complete more intricate features.
When given the same PRD, Cursor/Windsurf could be directed to document its understanding before coding, though the results were just “adequate” rather than exceptional.
Cons:
Cursor/Windsurf in agentic mode did not match Cline’s initial documentation thoroughness. While it performed tasks adequately, it never reached a truly exceptional level of proactive explanation or refinement.
When complexity rose (like with more complex downstream tasks), Cursor/Windsurf didn’t excel. It required a more hands-on approach from me, and the agentic mode didn’t save as much time as I had hoped.
And even when it runs locally, it may not run on build in deployment:
But in the end, I think this one looks the nicest, and it was as simple as giving the LLM a command to “build a nice-looking modern web app.” Sometimes, it can be that simple. And part of the fun of working ith LLM in coding
Lessons Learned and Recommended Workflow
After multiple trials, here’s the workflow I now recommend:
Start with Lovable or Bolt.new:
Use these tools to rapidly spin up a basic application version guided by the PRD. They do a good job aligning the initial codebase with your requirements and establishing a solid foundation.Version Control with GitHub:
Once you have a stable base, commit your work to GitHub. This provides a clean checkpoint and a safety net if subsequent agents make mistakes.Refine and Implement Complex Features with Cursor/Windsurf (Non-Agentic):
Check out the code from GitHub and feed the PRD into Cursor/Windsurf in a non-agentic mode. This approach lets you focus on specific tasks without worrying that the assistant will “go rogue” and break the existing codebase.Be Cautious with Cline (Agentic Mode):
If you use Cline (or other agents, cursor now offers agentic mode) for advanced tasks—especially those requiring real-time testing—prepare to pay for that luxury and have a rollback plan. While Cline’s documentation and initial planning are impressive, it can become unpredictable during complex iterative changes.
Documentation and Testing Practices
Documentation:
Cline stands out for producing thorough documentation before diving into code. If you need to have a well-structured understanding of your PRD reflected in code comments and architectural diagrams, start with Cline’s documentation mode. But remember to switch back to Lovable/Bolt or Cursor/Windsurf to avoid costly and potentially destructive agentic actions.Testing and Checkpoints:
Regularly commit changes to a source control platform like GitHub. This approach allows you to revert to a stable version if an assistant malfunctions. Also, consider disabling specific agentic commands that rewrite or delete major code sections unless you are confident you understand the consequences.
Cost Considerations
Using agentic modes to browse, test, and self-correct in real time can be expensive. If budget is a concern, stick to a more manual, guided approach with Lovable, Bolt.new, and non-agentic Cursor/Windsurf. Use Cline’s advanced features sparingly—perhaps just at the start for documentation or carefully scoped tasks.
Conclusion
No single assistant excelled at every stage. Each tool brought something unique:
• Lovable & Bolt.new: Great for starting development and partial customization.
• Cline (Agentic): Exceptional documentation and initial planning, but risky and expensive for iterative changes.
• Cursor/Windsurf (Non-Agentic): Reliable for incrementally adding features and refining the code after initial scaffolding.
My suggestion is a hybrid workflow: Kick off with Lovable or Bolt.new, use GitHub as a stable checkpoint, and then move the code to Cursor/Windsurf for incremental refinement. Use Cline selectively, mainly for upfront documentation or specific, well-defined tasks if you can afford the extra expense and risk.
Check out my GitHub repos of the Pomodoro Cline and Pomodoro Cursor apps to see the outcomes firsthand, and take a look at the screenshots from Cline’s agentic mode to see how powerful (and sometimes overzealous) it can be.