Pipesora

AI PROTOTYPES

From AI prototype to production

What to check before real users arrive.

Fahad Hossain · · 7 min read

AI coding tools have made it possible to get a working product in days. That is genuinely useful: you can test an idea with a real interface instead of a slide deck. But a demo that works on your laptop and a product that real people rely on are different things.

The gap is usually not the visible features. It is everything around them: who can see what, what happens when something fails, and whether anyone can safely change the code next month.

These are the areas we review when someone brings us an AI-built prototype.

Read the code nobody wrote by hand

Start by understanding what you have:

  • Structure: is the code organised so a person can find things, or is logic repeated across many files?
  • Dependencies: which packages are installed, are they maintained, and are any of them unnecessary?
  • Configuration: are environment settings, API keys and URLs kept out of the code?
  • Version control: is the project in a repository with a history, so changes can be reviewed and reversed?

AI tools are good at producing code that runs. They are less consistent at producing code that is easy to change. Some parts will be worth keeping; others will be quicker to rewrite than to repair.

Access and data

This is where prototypes most often fall short.

  • Authentication: use an established provider or library rather than custom login code.
  • Authorisation: check that each user can only see and change their own data. Test this directly: log in as one user and try to open another user's records by changing an ID in the address bar.
  • Secrets: API keys must live on the server, never in code that runs in the browser.
  • Personal data: know what you collect, where it is stored and who can access it. If you have UK users, UK GDPR applies from the first sign-up.

AI integrations

If the product calls an AI model, check how it behaves outside the happy path:

  • Cost limits: set spending caps with the provider and limit requests per user, so one person (or one bug) cannot run up a large bill.
  • Failures and slow responses: the interface should handle timeouts and errors clearly.
  • Untrusted input: treat model output as untrusted. Do not let it run commands, change records or send messages without checks.
  • Prompt injection: if the model reads content from users or the web, assume some of that content will try to change its instructions.
  • Logging: record enough to debug problems without storing more personal data than you need.

Reliability

A product people depend on needs a few unglamorous things:

  • Error tracking, so you hear about problems before your users tell you.
  • Backups of the database, and a restore that has actually been tested.
  • A staging environment where changes are checked before they go live.
  • Automated tests around the parts that would hurt most if they broke, such as sign-up, payments and permissions.

Decide what to keep, strengthen or rebuild

After the review, sort the product into three groups:

  1. Keep: parts that are sound and do their job.
  2. Strengthen: parts that work but need security, tests or tidying.
  3. Rebuild: parts where repair would cost more than starting again.

This gives you a realistic scope and cost instead of an open-ended "clean-up".

A short pre-launch checklist

  • [ ] Users can only access their own data, tested by hand.
  • [ ] No secrets in browser code or the repository.
  • [ ] Spending limits set on AI and other paid APIs.
  • [ ] Error tracking and uptime monitoring switched on.
  • [ ] Database backups running, and one restore tested.
  • [ ] Privacy notice and cookie consent in place.
  • [ ] Someone named who is responsible when things go wrong.

If you have a prototype and want to know what it needs before launch, share it with us. We will review the gaps and suggest a practical scope.