By Maciej Pyrc, who maintains Hype Stack.Updated .
The tool matters less than what it is pointed at. The same model produces good code in a codebase with conventions and slop in one without, which is why setup beats brand.
Vibe coding means describing what you want and letting a model write it. The tools that do this fall into three groups that get compared as if they were one, and picking from the wrong group is the usual reason people conclude the whole approach does not work.
We sell source code you clone and run yourself, and we have a direct interest here: the template ships editor rules that tell a coding agent how this codebase is structured. So take the last section as interested and the rest as the part worth reading either way.
Three groups, not one list
The honest pattern most people land on is a builder for the first day and an editor or terminal agent thereafter. The handover point is when the app needs something the builder cannot express, and how painful that handover is depends entirely on whether you can get the code out. For the builders that question is most of the comparison: Base44 vs Lovable is largely about which one lets you leave.
What actually determines output quality
Model choice matters less than people expect once you are on a current frontier model. Four other things matter more.
Whether the codebase has visible conventions
A model infers patterns from what is already there. A codebase with one way to fetch data, one way to handle errors, and one way to structure a feature gets consistent output. A codebase with four ways gets a fifth.
Whether rules exist in the repository
Editor rule files let you state conventions explicitly rather than hoping they are inferred. This is the setup step that changes output most, and it takes an afternoon.
Whether the feedback loop is fast and automated
Types, lint, and tests are how an agent finds out it was wrong without you reading the diff. A project with a fast typecheck and real tests lets an agent self-correct; one without makes you the compiler.
How much context the task needs
Tasks that touch one feature go well. Tasks that require understanding the whole system go badly, regardless of context window. Splitting work so each piece has a small blast radius is most of the skill.
The failure mode worth naming
The characteristic problem is not wrong code, which you notice. It is plausible code that works for the case you tested and quietly does the wrong thing elsewhere: an unhandled error path, a query that is fine on ten rows, a permission check that was never asked for so was never written.
Two habits help. Review generated code as though a stranger wrote it, because one did. And be specific about the non-functional requirements up front, since a model will not ask whether this endpoint should check that the user owns the record.
Where the approach genuinely struggles
Greenfield features in a well-structured codebase go well. Three situations do not.
Debugging something subtle, where the model will confidently propose fixes for the wrong cause and each one costs you a review cycle. Work requiring a decision about trade-offs, since it will pick one without telling you it chose. And anything where being almost right is worse than not attempting it, which usually means money, auth, or data deletion.
Where a template fits
This is the interested part. A model writing a signup flow, an organisation model, or Stripe webhook handling is producing code that already exists in a thousand repositories, and it will produce a version with the errors a thousand repositories made. Webhook idempotency is the usual example: Stripe retries and reorders events, and code that assumes each one arrives once will look fine and double-count.
Starting from code that already handles that means the agent spends its attention on what is specific to you. The template also ships the editor rules mentioned above, describing how backend features are structured, how errors reach central middleware, how data fetching uses the typed SDK, and how tests are written, which is the difference between an agent guessing your conventions and being told them.
None of that removes the review. It narrows what you are reviewing to the part that is actually yours.
Below are the templates and packs. If you are evaluating tools, the more useful experiment is to spend an afternoon writing rules for whatever codebase you already have, then compare the same tool before and after.
Once the tool is chosen, the setup matters more than the choice: How to Vibe Code with Claude and Agentic Coding Tools 2026, and if the tool is a builder rather than an agent, Bolt vs Lovable.