← Back to blog
Decisões técnicas May 26, 2026 11 min read

When to fire Lovable and hire a developer — 7-signal decision matrix

If 2+ of these 7 signals show up in your vibe-coded SaaS, stop iterating and hire a dev. Closed matrix with scoring and action band per tier.

U
Ulisses Hen
Founder · Hens Desenvolvimento

Direct answer first: if you check 2 or more signals on this list, stop iterating in Lovable/Bolt/Replit and hire a human developer for spot code review. If you check 5 or more, hire a senior dev full-time to lead a rewrite — the product is in tech debt that doubles every sprint.

I built two SaaS solo — OverAir (WhatsApp digital memory, 0 paying customers today, I'll be upfront about that) and Studio Kallos (booking for beauty studios). Both run in production. In parallel, in 2026 I've consulted with at least 4 Lovable SaaS founders — same pattern every time: they show up when the app stalls around ~200 users, infra bill triples in a month, and nobody understands the code anymore.

This post is the matrix I use, in 30 minutes of conversation, to decide whether a spot review fixes it or it's time to retire the tool. Seven signals. Scoring system. Action band.

Why this matrix exists

DX/Apiiro study published December 2025: AI-generated code has 10.83 issues per request vs 6.45 for human code — 1.7x more bugs (The Register, Dec 2025). Not an opinion — a measurement on real pull requests.

Worse: 40–62% of AI-generated code contains security flaws (Kyros, 2026) and 42% of companies abandoned most AI initiatives in 2025, more than double the 2024 rate (Beam, 2026). Forrester projects 75% of tech decision-makers will face moderate to severe tech debt in 2026 — a big chunk of it induced by vibe coding without governance.

The question isn't "will I have tech debt?". It's "when will I stop pretending I don't?".

The matrix below is the ruler. The seven signals are symptoms I've seen in the field — none invented. Each one is worth 1 point.

Signal 1 — You've rebuilt the same feature 3 times

Classic pattern: the vibe-coder ships 70% of the feature in 2 hours, you're happy, you push to beta. A bug shows up. You ask the agent to fix it — it "fixes" but introduces another bug. You ask it to fix the second one — it breaks the original feature. You revert. You start from scratch because it's cheaper in credits than untangling what it did.

This loop isn't agent incompetence. It's the agent's nature. Lovable, Bolt, and Replit don't keep a persistent mental model of your system — they re-read the code on every prompt and re-deduce intent. As the codebase grows, regression risk scales linearly.

Hidden cost: each rebuild eats 5–15 credits. On Lovable Pro (Lovable Pricing) you get 100 credits a month for $25. Three rebuilds of the same feature consume ~30% of your monthly budget. I've watched a founder burn through Pro in 8 days over a single screen that wouldn't close cleanly.

Score it: check this signal if at any point in the last 30 days you thought "easier to just rebuild from scratch". You're already paying the price of lost context.

Signal 2 — Monthly infra crossed $40 and you still have under 1,000 users

This is the coldest signal because it's a number, not a feeling.

Healthy band for a SaaS under 1,000 active users on traditional stack (Firebase Spark + Cloud Functions, or Supabase Free): $0 to $15/month. If you crossed $40/month with fewer than 1,000 users, something is misshaped — usually one of three things:

  1. N+1 queries. The agent wrote a loop that queries per item instead of batching. Dashboard page with 50 cards = 50 queries. Multiply by 200 concurrent users.
  2. Real-time left open everywhere. Lovable loves WebSockets to feel "modern". Each concurrent connection counts toward your Supabase quota. By 500 active users, you blow past the Pro $25 ceiling (Supabase Pricing) and land on Team at $599/month.
  3. Media storage with no lifecycle. In a system with audio and image uploads that I worked on, the agent didn't write a lifecycle policy. Everything became a permanent bucket. The bill climbed $80/month over 4 months — nobody noticed.

For a WhatsApp bot in production I shipped recently, the client came from Lovable paying $180/month for 350 users. I rewrote 3 endpoints, moved audio jobs to Cloud Tasks with retry, dropped it to $28/month. The client saved $152/month — three months of consulting paid for by the infra savings alone.

Score it: check this signal if the bill crossed $40/month. Doesn't matter how "premium" the plan sounds.

Signal 3 — You're stacking 3+ AI tools without clarity on when to use which

Bolt for MVP. Lovable for editing. Cursor for local refactor. Claude Code for debugging. Replit for deploy. v0 for new UI.

When your AI stack has more tools than your code stack, the tool became the product — and the product disappeared.

Each one charges its own subscription. Bolt Pro: $25/month with 10M tokens (Bolt.new Pricing). Lovable Pro: $25/month with 100 credits (Lovable Pricing). Cursor Pro: $20/month. Claude Pro: $20/month. Replit Core: $25/month. Running all five costs $115/month in AI alone — and the product still doesn't work right.

Worse: each agent formats code differently. Bolt uses Vite + structure A. Lovable uses Vite + structure B with duplicated helper-utils. Cursor suggests a refactor that breaks both. The result is a patchwork where nobody — not you, not the next developer — understands why each decision was made.

Score it: check this signal if you pay for 3+ AI tools to build the same SaaS. Without clarity on which tool owns which scenario, that's stack debt, not productivity.

Signal 4 — The same critical bug came back 2+ times

A duplicate Meta webhook charged a customer twice. Race condition on order approval. Corrupted data because a cron ran in parallel with another process. A bug you "fixed" 3 weeks ago that came back yesterday.

The vibe-coder doesn't have a mental model of your system. Every fix is local: it reads 200 lines, suggests a patch, leaves. When the root cause is architectural — missing idempotency, missing locks, missing dedup queues — the patch only hides the problem for a few weeks.

I wrote a whole post on duplicate webhooks and idempotency, but the gist: Stripe documents ~0.5% of webhooks being delivered twice in production. On 1,000 charges/month that's 5 chargebacks/month at $15 dispute fee = $75/month in pure leakage — before counting the angry customer. Lovable doesn't write idempotency by default. Neither does Bolt. Cursor writes it if you ask explicitly, but the Lovable agent doesn't know it needs to ask.

Score it: check this signal if the same bug (same class, same root cause) reappeared in the last 60 days. You're not fixing — you're postponing.

Signal 5 — A stakeholder asks "how does X work" and nobody can explain

This is the bus factor 1 signal — or bus factor 0, which is worse.

2015–2016 study measuring 133 popular GitHub projects: 65% have bus factor ≤ 2, meaning if 1 or 2 people leave, the project stalls (Wikipedia: Bus factor; IEEE: Assessing the bus factor of Git repositories). In vibe-coded SaaS, the math is worse: the agent doesn't count as "someone who knows". Only you do — and even then, partially.

The test is simple. Grab the investor, the cofounder, or your next dev hire and ask: "explain in 5 minutes how the payment flow works, from checkout to the Stripe webhook updating the database status". If you can't — because the code is spread across 12 files with duplicated helpers the agent created as shortcuts — bus factor 1 is confirmed.

In a legacy Delphi-to-web migration I led years ago, the client carried bus factor 0.5 — the only developer who understood the system had vanished and nobody could explain the commission calculation. It took 4 months just to document the rules before any rewrite started. Vibe coding creates that scenario in 6 months instead of 6 years — that's the only real "acceleration" it delivers.

Score it: check this signal if you or your team can't explain the system architecture in 10 minutes on a whiteboard.

Signal 6 — One area of the code nobody touches anymore

You know which one. That billing endpoint. That reporting screen. That nightly job. When someone proposes touching it, the conversation drifts elsewhere.

In a human team, radioactive code shows up in 10+ year legacy systems. In vibe coding, it shows up at 4 months.

The mechanic is simple: the agent generated a solution in that area following pattern X. You asked for a tweak, it applied a patch outside pattern X. You asked for another tweak, it created a new helper with a name suspiciously close to one that already existed. Now that area has 3 patterns coexisting, 2 helpers doing nearly the same thing, and the local test breaks in 4 different ways depending on which path the request takes.

Cursor doesn't get you out — it reads the code, sees the chaos, and suggests "maybe rewrite this module". So you go back to Lovable to rewrite it, and lose 2 features that were working.

Score it: check this signal if there's a folder, file, or feature nobody wants to open. If you hesitate before accepting a change ticket against it, it's radioactive.

Signal 7 — A hired dev for code review quit mid-way

This is the terminal signal.

You hire a senior freelancer to code-review what Lovable generated. Negotiate scope, settle a rate — in the US, senior dev contractor rates land between $80 and $150/hour; Brazilian senior median is $42/hour in 2026 per Lemon.io data (Lemon.io: Software Developer Salary & Hourly Rate in Brazil 2026); UAE rates for senior contractors run AED 350–550/hour for nearshore work. You agree on 20 hours of review.

By hour four, the freelancer messages you: "Hey, I think I'm going to refund this. The code isn't refactorable — it's rewrite or continue patching forever". And they're right.

When a paid senior developer — with a deadline, with a promise to deliver — prefers to refund the money rather than continue, the signal isn't "I picked a bad freelancer". It's "the code is past the point of cosmetic repair".

In consulting work I picked up in 2025–2026, I saw this twice — always on Lovable SaaS at ~500 active users where the founder asked for "just a security review". The review turned into a diagnosis, the diagnosis turned into a rewrite proposal. In both cases the founder didn't accept the rewrite and shut the product down 4 months later.

Score it: check this signal if you hired a dev to review and they bailed or recommended rewrite instead of patch.

The closed matrix — score and action

Sum your checked signals. Action by band:

Score Diagnosis Recommended action Estimated cost (US/UAE)
0–1 Healthy Keep iterating in Lovable/Bolt. Keep discipline on manual testing and DB backups. $25–50/month (subscription)
2–4 Manageable tech debt Hire a senior dev for spot code review — 8–16 hours/month. Focus: idempotency, N+1 queries, dedup. $640–2,400/month
5–7 Structural debt Hire a senior dev full-time (or agency) to lead partial or full rewrite. Lovable goes away. $12k–22k/month full-time, or $25k–80k fixed-scope rewrite

US/UAE freelance numbers come from real 2026 market data: senior contractor 8h/month at $100/hour = $800. Full-time senior US contractor $12k–18k/month loaded; UAE senior $14k–22k/month. Good Brazilian nearshore agencies charge $25k–80k for a 4–8 week partial rewrite — scales with product size.

Where I wouldn't keep paying Lovable, with conviction

Direct take: if you checked 5+ signals and you're still paying $50/month for Lovable Business, you're burning money in two pockets — the tool creating the debt AND the dev you'll hire to fix it. Cancel Business the moment you sign the dev. Keep Pro or Free for prototype work only.

And a stronger opinion that cuts against every AI startup pitch in 2026: vibe coding does not scale to a product with recurring billing and an SLA. For validation prototypes, MVPs you push to 20 friends, internal tools without sensitive data — perfect. For anything that charges a card and promises uptime, switch before you hit 200 active users. After that, the switching cost doubles every 200 new users.

Where vibe coding genuinely wins:

  • Idea validation in 48h. Lovable in 2 days gives you an app to show a potential customer. Use it, validate, throw it away.
  • Landing page + internal dashboard. No sensitive data, no billing, no SLA. Worth the $25/month.
  • Internal tool for a team of 5. Throwaway by design. No refactor expected.

Where I wouldn't go, even with traction:

  • B2B SaaS with recurring billing. A single chargeback or 2-hour downtime eats 6 months of "Lovable savings".
  • WhatsApp bot in production. I wrote the hardening checklist — Lovable doesn't cover idempotency, Meta rate limits, FCM rotation, dedup. Not worth it.
  • Mobile app. Lovable doesn't ship native Flutter. It ships React + capacitor that looks like an app but Apple rejects in ~70% of reviews.

What I'd do tomorrow, if I were you

  1. Sit with the matrix above. Score the 7 signals honestly. Don't inflate to justify what you already wanted to do.
  2. Score 2–4: hire a dev for 8h of review this week. Don't buy more Lovable credits until they deliver the diagnosis.
  3. Score 5–7: cancel Lovable Business today. Keep Pro or Free. Open a job listing or contract an agency for a 4–8 week rewrite. Tell your top 10 customers a change is coming — they'll handle it better now than during a production incident.
  4. Document everything you know about the system in a README while you still remember. Before the new dev arrives. Bus factor 1 climbs to 2 just by writing it down.

It's not elegant. It's not the path the Lovable pitch promises. But it's the only exit I've seen work across 4 separate consulting engagements in 2025–2026 — and the only one that comes out the other side with a product still worth money.

Sources

Want an app like this for your business?

Hens builds Flutter apps, AI-powered WhatsApp bots and custom backoffice systems — with the same rigor we apply to our own products. From MVP to production. First call is direct, no form.

Talk on WhatsApp →