AI code rescue

It demoed beautifully. Now it has to survive production.

AI coding tools get you to something that works, faster than anyone expected. What they do not give you is a security review, a deployment, tests that mean anything, or someone to call when it falls over at 2am. That is the part we do.

Symptoms

What usually brings people to us

  • It works on the machine it was built on, and nowhere else.
  • Every new feature quietly breaks an old one, and no test catches it.
  • There are API keys in the repository, and nobody is sure where else they went.
  • The same logic exists in four files, each version slightly different.
  • Nobody can explain how a given part works, including the person who prompted it.
  • There is no staging, no backups and no idea what happens under real load.
  • It is live already, and that is exactly the problem.

How the work goes

Read it properly first
A full pass over the code to separate what genuinely works from what merely looks like it should. You get the findings whether or not you hire us for the rest.
Stop the bleeding
Exposed secrets, missing authorisation checks, unvalidated input and anything that loses data. Security and correctness before tidiness.
Make it changeable
Cut the duplication, settle on one way of doing each thing, and put tests around the behaviour that matters — so the next change is safe.
Ship it and keep it up
Real environments, a deployment pipeline, monitoring and backups. Then either your team takes it, or we keep running it.

Services

Where we come in

Code and architecture audit

A written assessment of what you have: what is sound, what is unsafe, what has to be rewritten and what it would take. Often the whole engagement.

Security hardening

Authentication and authorisation that actually holds, secrets moved out of the code, input validation, and an audit of the dependencies the model chose.

Clean-up and refactoring

Removing the duplication and the half-finished abstractions, fixing the data model, and reducing the codebase to something a person can hold in their head.

Tests and CI

Tests written around the behaviour you care about rather than for a coverage number, running on every change, with a build that fails honestly.

Deployment and infrastructure

Separate environments, reproducible infrastructure, migrations that run themselves, and backups that have been restored at least once.

Run it, or hand it over

Logging, alerting and on-call if you want us to operate it — or documentation and pairing until your own developers are comfortable owning it.

Scope

We do not mind how it was written

A prototype from an AI agent, an offshore handover, a side project left behind by a contractor — the work is the same. Someone has to read it, understand it and take responsibility for it. We are comfortable inheriting code.

Claude Code Cursor GitHub Copilot Lovable v0 Replit
TypeScript React Next.js Node.js Python FastAPI Django PostgreSQL Supabase
Docker Terraform GitHub Actions GitLab CI AWS Azure

Questions

Before you ask

Usually not. The product decisions embedded in a working prototype are worth real money, and a rewrite from zero throws those out along with the code. Hardening what exists is normally cheaper. When a rewrite genuinely is the right call — and sometimes it is — we say so early, with the reasoning, rather than discovering it three months in.

No. It is as good as the instructions and the review it got. Given a clear specification and someone reading every change, the output is fine. Generated from a vague prompt by someone who cannot evaluate the result, it produces code that looks plausible and behaves badly — and it produces a great deal of it, quickly. The volume is what makes it expensive later.

Daily, and that is part of why we know where they fail. The difference is that a senior engineer reviews every line before it lands, and we stay on to run what we ship. Nothing reaches your production because a model sounded confident about it.

It is common, and it is workable. We read the code rather than relying on anyone's account of it. What we do need from you is what the system is supposed to do for the business — that part cannot be recovered from a repository.

The audit is typically one to two weeks and stands on its own. Taking a small application from there to a monitored production deployment is usually weeks rather than months — the codebase already exists, and that is normally the part that takes longest.

Sitting on a prototype nobody will sign off?

Send us the repository, or just describe what it does and what worries you about it. We will come back with an honest read on what stands between it and production.