VeloDev
/ Case Study

AI assistant for car workshops

Mechanic Copilot is a bilingual mobile app for small garages. Each vehicle has a record and each visit is a case: symptoms, OBD-II codes typed in by the mechanic, photos, audio and video. On request, an AI assistant turns the case into an investigation plan. The mechanic works through the checks, confirms the diagnosis and closes the case into the vehicle's history.

Role
Creator
Category
Mobile app / AI
Platform
Android (Google Play)
Status
Live on Google Play — beta
Technology Stack
  • Expo
  • React Native
  • TypeScript
  • Hono
  • PostgreSQL
  • Drizzle
  • Better Auth
  • Vercel AI SDK
  • Gemini
  • Zod
  • TanStack Query
  • i18next
APP SCREENS (5)

Select tabs to view app screens (the app is shown in Romanian). Click the phone to zoom.

Mechanic Copilot
01 / 05

AI analysis

The investigation plan for a case: the safety warning comes first, then urgency, a summary and the observations taken from the case. The app and its demo data are in Romanian here.

/ Engineering snapshot

Challenge

Give a small workshop an AI assistant for diagnostics without letting it act like the mechanic: a safety-sensitive domain, a phone used on the shop floor, and an assistant whose output the mechanic must be able to check, correct or ignore.

What I owned
  • Product definition and scope: what the assistant does (suggests causes and checks) and what it refuses to do (give a verdict).
  • The whole stack: Expo mobile app, Hono API, Postgres data layer, file storage and the AI layer.
  • The AI safety rules: prompt design, structured output, fixed safety warnings and the evaluation fixtures.
  • The delivery process: I directed the build through a multi-agent Claude Code workflow, where every task goes through code review, a security review where it applies, tests and an acceptance check.
Result
  • Live on Google Play as a beta, in Romanian and English, with a 14-day free trial that includes up to 30 AI analyses.
  • An AI feature that is never the last step: plan, then checklist, then the mechanic's own confirmation, then the vehicle history.
  • Every analysis validated, versioned and costed, and prompt changes checked against evaluation fixtures before they ship.
Key engineering decisions
  1. The AI suggests, the mechanic decides

    The assistant returns a plan, never a verdict: possible causes with the data behind them, checks ordered from non-invasive to invasive, questions for missing information and safety warnings. It is instructed not to recommend replacing a part before a check confirms it, and the diagnosis only exists once the mechanic confirms it and closes the case.

  2. Safety warnings that do not depend on the model

    A fixed set of rules in code looks for brakes, steering, fuel, airbags, overheating, smoke and high-voltage battery, in Romanian and English. It adds its own warnings to the model's and can only raise urgency, never lower it. A wrong or missing answer from the model cannot silence a warning.

  3. One schema for the network and for the AI

    Zod schemas in a shared package define every request and response shape and the AI output itself. The model's answer is validated against the same schema the app renders. If it does not parse, the API makes one repair request and then fails cleanly; a failed analysis does not use up the trial quota.

  4. The model behind an adapter, the prompt as versioned code

    The Vercel AI SDK sits behind a small adapter, so the provider and model are configuration (Gemini today) and tests run on a scripted fake model. Each prompt version is its own module that stays unchanged once released, and every stored analysis records which version produced it.

  5. Cost and abuse controls from the first version

    Photos are limited and downscaled, output length is capped, each workshop has an analysis quota, each user a rate limit, and tokens and cost are logged for every run. A model call can never grow into an open-ended bill.

/ how the AI is used

On request, the assistant reads the case and returns a structured investigation plan. It is a starting point for the checks the mechanic does on the car, not a diagnosis.

Possible causes, with an evidence level

Each possible cause lists the data that supports it and how strongly the data supports it (low, medium or high). Observations taken from the case are kept apart from hypotheses.

Checks, non-invasive first

Recommended checks are ordered from non-invasive to invasive and become a checklist. The assistant is instructed not to recommend replacing a part before a check confirms it.

Missing information, as questions

When a case is thin, the assistant asks for what it needs: symptoms, codes, readings. The mechanic answers in the case notes and can run the analysis again, with the checks already done taken into account.

Safety warnings first

When a case touches brakes, steering, fuel, airbags, overheating, smoke or a high-voltage battery, the warning appears first on screen. It comes from the model and from fixed rules in the app, so it does not depend on the model alone.

/ system design

An Expo app talks to a Hono API. The API owns authentication, workshop scoping and validation, keeps data in Postgres and files in S3-compatible storage, and is the only place that calls the model. Everything around the model call is plain code.

Mobile app
code
Expo · React Native · Expo Router · TanStack Query · react-hook-form + zod · i18next
API
code
Hono · Better Auth · workshop-scoped queries · zod validation
Postgres
data
Drizzle · vehicles, cases, checks, analyses
Object storage
data
S3-compatible · presigned uploads for photos, audio and video
Context builder
code
Case text, OBD codes, earlier cases, at most 4 downscaled photos. No VIN, no plate number.
Gemini
model
Vercel AI SDK · structured output against a zod schema
Checks before the mechanic sees it
code
Schema validation (one repair retry) · text sanitised · fixed-rule safety layer · stored with prompt version, tokens and cost
Tags show who does the work: plain code, stored data, or the model. Only one step is a model call.
/ reliability & safety

A model answer is treated as untrusted input: it is parsed, checked, corrected by rules and logged before the mechanic ever sees it.

Versioned prompt

  • Each prompt version is a separate module and old versions stay unchanged.
  • Every stored analysis records the prompt version, so any past result can be traced.
  • A prompt change means a new version and a new evaluation run.

Evaluation fixtures

  • A set of synthetic cases in Romanian and English: common faults, intermittent faults, thin cases, safety cases and off-topic input.
  • A harness scores schema validity, safety warnings, forbidden certainty phrases, check order and cost per run.
  • Recorded model answers can be replayed offline, so scoring does not need a new model call.

Fixed-rule safety layer

  • Runs in code after the model and adds a standard warning per safety domain it detects.
  • Only raises urgency, never lowers it, and a model that stays silent cannot remove a warning.
  • Text in a case that asks for fewer warnings is treated as data, not as an instruction.

Cost and limits

  • Photos capped at 4 and downscaled, output length capped, earlier cases truncated.
  • An analysis quota per workshop and a rate limit per user.
  • Tokens and cost are logged for every analysis.
/ data & privacy

The assistant gets only what it needs to suggest checks. Identifiers and recordings stay out.

Sent to the AI

  • The case text: symptoms, when the problem appears, notes and OBD codes.
  • A few earlier closed cases of the same vehicle in the same workshop.
  • At most 4 photos, downscaled and re-encoded on the server with metadata removed.

Never sent to the AI

  • The VIN and the plate number.
  • Audio and video recordings.
  • Account email, user name and workshop name. Anything typed into a case is marked as data inside the prompt.

A workshop's data is visible only in its own account, and the account and its data can be deleted from the app, in Settings. The AI analysis needs an internet connection; a new case can be started offline as a draft and saved when the connection returns.

/ limits

Mechanic Copilot is a beta, and it is built to say so.

Suggestions need a mechanic

The generated suggestions can be incomplete or wrong and must be validated by a qualified mechanic before any repair. The app says so on the analysis screen.

Not an OBD scanner

OBD codes are entered manually, after the mechanic reads them with their own scan tool. The app shows the generic description of a code and does not connect to the car.

Beta, account required

The app is in beta on Google Play and needs an account. Features and wording may still change.