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
- Expo
- React Native
- TypeScript
- Hono
- PostgreSQL
- Drizzle
- Better Auth
- Vercel AI SDK
- Gemini
- Zod
- TanStack Query
- i18next
Select tabs to view app screens (the app is shown in Romanian). Click the phone to zoom.
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.
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.
- 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.
- 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Hiring for a senior full-stack role, or need something like this built?
marian.putirac@gmail.com