Built with Cursor

Cursor keeps breaking something else while fixing the same thing.

Cursor is genuinely good at the file in front of it, and the problems start where a change has to be true in four files at once. After a few weeks of that, what you are chasing is not a bug so much as two parts of your own project disagreeing.

Book my audit

What usually breaks in Cursor

Two Composer sessions, two homes for the same state

The same value is held in two places that were each written to be correct on their own — a context and a local hook, a cached list and a fetched one. Whichever wrote last wins, so behaviour changes with the order you click things and no single file looks wrong when you open it.

Edits written against a stale codebase index

A change lands against what the index remembered rather than what the file says now: a function called with its arguments in the wrong order, a field renamed months ago, a helper that already exists three directories away and now exists twice. The code reads plausibly, which is exactly why it survives review by the person who asked for it.

The bug moves every time it is fixed

Each round patches where the symptom appeared instead of where it started, so the failure relocates rather than going away. The tell is a week of work where the app is always nearly right and never right, and it stops only when somebody traces one failing case from the click to the response.

The types and the data have drifted apart

Interfaces were written to describe a shape that has since changed at the source, and the gap was closed with a cast or an optional field to make the build pass. The compiler is now agreeing with a description of your data rather than with your data, and the runtime errors read as impossible.

Symptoms we see most in Cursor projects

Is this a problem with the tool or with how I used it?

Neither, mostly. It is what happens when changes accumulate faster than anybody holds a picture of the whole system, which is the normal cost of moving quickly. The audit puts that picture on paper so you can keep going at the same speed with something to check against.

Do you need to see my repository?

Yes, read access to the branch that is failing, plus one case you can describe that goes wrong. We do not need your production credentials to read code, and if reproducing it needs data we will ask for a sample rather than the database.

Will you rewrite my project?

No. We repair the specific disagreements we find and leave your structure alone, because a rewrite hands you a new codebase you have never read. If the honest answer for one area is to redo it, that appears in the findings with its own price.

How do I stop it coming back?

The written findings name the places where one idea lives in two files, which is what makes the next change safe to prompt. Where a test would have caught the whole class of failure, we say which one and what it costs to add.

How it works

Audit

$199~~$349~~promo

You send a link, a repo, or both. We reproduce the problem, read the code, and record a short walkthrough: what's broken, why it broke, and what it takes to fix. You get written findings and a fixed quote.

Book my audit

Full Fix

Priced after the audit

Scoped from the audit and agreed before anything starts. We fix the cause rather than the symptom, and hand back something maintainable, with a written note on what changed and why.

Nobody can price this honestly before seeing the code. The audit is what makes a firm number possible.

The audit is a fixed price and you know it before you pay. Everything after it is quoted from what the audit actually found, and you approve the number before any work starts.

Why trust us with it

What we can show you is who does the work, what it costs, and how well we already know the failure you are staring at.

A desk at night, the walkthrough being recorded

A small agency, not a marketplace

This is run by a small web agency. The person who records your audit is the person who does the fix, so you're not being routed to an anonymous bidder.

$199~~$349~~promo

The audit stands on its own

Plenty of people take the findings and do the work themselves, or hand them to their own developer. That is a fine outcome and nothing is bundled to stop it.

Book my audit

Fixed price, agreed up front

You approve a number before work starts. If the job turns out harder than we estimated, that's ours to absorb, not a change order.

Built with one of these? You're in the right place.

Lovable: Lovable projects usually break at the Supabase edge: environment variables that never reached production, or row-level security left open on a table that holds real customer data.
Bolt: Bolt ships fast and leaves the build config behind. The deploy fails on a missing package, a Node version, or an API key that only ever existed in the preview.
Replit: Replit apps run fine in the workspace and 500 on a real domain: ports, file paths and secrets that were never wired up for the deployed process.
Cursor: Cursor edits confidently across files it has not read. Two features end up disagreeing about the same state, and the bug moves every time you fix it.
v0: v0 gives you the interface, not the wiring. Forms post to nothing, server actions are still stubs, and auth is a component rather than a session.
Windsurf: Windsurf refactors reach further than intended. Imports, types and routes drift apart until the build stops on something unrelated to what you changed.
Base44: Base44 apps hit their ceiling at data and roles: the model that fit the demo cannot carry a second kind of user without redoing what sits underneath it.
Claude Code: Claude Code writes real code, which means real dependencies, migrations and tests. When it breaks, it breaks somewhere prompting cannot reach.

What it usually turns out to be

It works locally, then 500s once deployed: Nearly always an environment variable, a build step or a file path that only exists on your machine. The code is usually fine.
The AI keeps fixing the same bug: Each pass patches the symptom because the cause sits a layer down, in the data model or in how state is shared. Prompting harder does not reach it.
Forms submit but nothing arrives: The browser gets a success back while the server quietly fails. Without error handling and logs nobody finds out until a customer complains.
Logins drop or leak between users: Session and auth code copied from an example built for a different rendering model. It looks right in testing and breaks under real traffic.

And what nobody notices until later

Security is the part an AI builder is quietest about. None of these stop the app working, which is exactly why they ship.

The database is open to anyone with the URL: Supabase and Firebase hand the browser a key on purpose — the row policies are what actually guard the data. Generated projects routinely ship with those policies off, which turns a public key into a key to everything.
Secrets that shipped to the browser: A service key pasted into a component, or one prefixed NEXT_PUBLIC_ so the build would stop complaining. It is in the page source, readable in devtools, and the bill for it is yours.
Any logged-in user can read every other user's data: The endpoint takes an id and returns that record without ever asking whose it is. Nothing looks wrong while you are the only account; change the number in the URL and you are in someone else's.
Nothing stops the same request a thousand times over: No rate limit and no real validation on the public routes, so login, password reset and checkout can each be hammered until something gives. Generated code almost never adds this on its own.

If you recognised your own problem somewhere above, that is the point. The audit is where you find out which one it actually is.

Book my audit

$199~~$349~~promo

Send it over. We'll tell you what's wrong.

One fixed-price audit at $199 instead of $349. A video walkthrough, written findings and a firm quote on what it takes to fix.

Book my audit