Rewrite or rescue? Don't buy the verdict — buy the reasons

You probably won't call anyone the day your app breaks. You'll keep prompting. You'll call when the credits, the patience or the confidence run out, and the first thing you'll ask is: rewrite or rescue?

You can't check the answer to that question. So our advice is short. Don't buy the verdict. Ask for the reasons, in writing, before anyone names a price.

When founders actually call

Afterbuild Labs, a shop that sells rescue work, published an audit of 100 apps built with vibe coding tools. In that audit, the moment a founder reaches out is not a specific bug. It is when the “founder runs out of credits, patience, or confidence”, which the audit calls “the conversion point for every other failure mode.” The searches it lists look like “fix my broken AI app” and “hire lovable developer.”

The same audit names a separate failure mode: “Decision paralysis — rewrite or rescue?” The founder “can't evaluate code quality themselves; afraid of both outcomes.” It says this shows up “in most pre-engagement conversations.”

These are a vendor's figures about its own market. Read them that way. We still think the pattern is worth taking seriously, because in our view it describes the exact moment you are most likely to accept an answer you can't verify.

Rescue already has a price list

Fixing an AI-built app is now a category with published prices.

JetThoughts, another rescue shop, publishes worked examples. Two of its numbers: an MVP bought for $28K became an $89K MVP, and a contract that set aside $4K for QA ended up spending $38K on it — 9.5 times the line item.

The market has adjusted. According to the same source, the first step these shops sell is now an audit, and a fixed price set after the audit works as a trust device. The remediation bill is fixed before work starts.

That fixes the price. It doesn't fix the verdict. Our view: a fixed price on the wrong call is still the wrong call.

Why “rewrite” on its own is worth nothing to you

People who review AI-built codebases describe a change in their first question. It used to be “is the code good?” Now it is closer to “does anyone here understand it?”

Apply that to the verdict you're about to pay for. “Rewrite”, with no account of what was read and why, repeats the problem you already have. Code nobody in the room can explain gets replaced by a decision nobody in the room can explain.

You can't evaluate code quality. You can evaluate whether a sentence names a place, a number and a reason.

The strongest case for just buying the verdict goes like this: you're exhausted, you hired an expert precisely so you wouldn't have to judge this, and the reasons will be technical anyway. We take that seriously. But you don't need to understand the reasons to use them. Written reasons can go to a second reviewer, who confirms or disputes them line by line. A spoken verdict can only be trusted or not.

What to ask for, before any price

The complaints founders repeat about shops, in the JetThoughts collection, are procedural rather than technical: repository access promised only “at the end”, an agency that can't state its test coverage number. Each one converts into a line you can ask for up front.

BEFORE ANY PRICE — please send in writing

1. Access
   - Read access to my repository, now, not at handover
   - The branch and commit you actually reviewed

2. What you read
   - Areas reviewed
   - Areas not reviewed, and why

3. What you measured
   - Test coverage today: __%
   - The exact command you ran to get that number

4. The call, part by part
   - Keep:     <part>   because <reason>
   - Fix:      <part>   because <reason>
   - Replace:  <part>   because <reason>, and what breaks if we don't

5. What would change your mind
   - The fact that would turn "rewrite" into "rescue", or back

In our view, section 5 is the most useful. A verdict that no fact could overturn isn't an assessment. It's a preference.

How to read what comes back

You don't have to judge the code. Judge the document. The rows below are illustrative, not quotes from a real review.

What the answer says                   What it tells you
-------------------------------------  ---------------------------------------------
"The codebase is a mess"               A verdict. No place, no number, no reason.
"Session checks exist in three         A reason. Names a place and a fact a second
 places and disagree on expiry"         reviewer can confirm in the repo.
Coverage: "decent"                     Not measured.
Coverage: a number plus the command    Measured, and someone else can rerun it.
Access "at the end"                    The same risk that got you here.
Nothing listed under Keep              Either true, or nobody looked closely.
Section 5 left blank                   The verdict can't be wrong, so it can't be
                                        checked.

None of this requires you to read a line of code. It requires the person you're paying to show their work.

FAQ

Isn't the audit itself the verdict?

An audit is a sensible first step, and according to JetThoughts it is now the standard one. What matters is what the audit hands you. If it ends in one word, you bought a verdict. If it ends in the list above, you bought reasons you can take to anyone.

What if the reasons are too technical for me?

They aren't there for you to judge line by line. They're there so a second reviewer can confirm or dispute them. A reason that names a place and a fact can be checked by someone else. A bare verdict can't.

Will a shop agree to write this before quoting?

Some will, some won't. Our view: a refusal is useful information. Repository access promised only at handover is one of the recurring complaints founders make about shops, in the collection cited above.

Is “rewrite” always the expensive mistake?

No. In our experience, sometimes the data model genuinely has to be rebuilt, and a rescue on top of it only postpones that. The goal isn't to avoid the word “rewrite”. It's to know why it was said.

Where do the numbers in this piece come from?

The audit of 100 apps and the “rewrite or rescue” failure mode come from Afterbuild Labs. The $28K → $89K example and the $4K → $38K QA overrun come from JetThoughts' published examples. Both firms sell rescue work, so we attribute their figures rather than restate them as fact.

A related case

The same rule runs through one of our own builds. In RE Intelligence, every number comes from a deterministic query and the model only narrates what the data already proved. Forecasts are graded against what actually happened, with the accuracy shown to the user. The reader checks the figure instead of trusting it. Read the RE Intelligence case.