One file changed the way we build. A user uploaded a recording, our system processed it, and the job was marked complete. The transcript, however, contained almost nothing.
That single incident became one of the most valuable lessons for our AI transcription product at Trustample because it exposed a truth about AI systems that conventional software does not prepare you for. It is also the reason the platform today verifies its own output before any user sees it. This is the story of how that safeguard came to exist.
Trustample turns audio and video recordings into editable text. It supports sixteen languages, and when a user does not specify which language a recording contains, the system attempts to identify it automatically. That feature is where the story begins.
When a language is not specified, the speech recognition model makes an informed guess. Most of the time, the guess is correct, sometimes it is not, and sometimes a recording of Spanish speech is processed as though it were English.
Here is what I expected in that situation: an error, a failure code, something that lands in our monitoring and tells us that a job went wrong.
But this is not what happens.
The model does exactly what it was asked to do. It listens to Spanish speech as though it were English and many times produces the closest English words it can find. It returns a response that looks completely normal. The pipeline receives that response, sees no error, stores the result, and marks the file as done. The user opens the transcript and finds very little text there. The dashboard shows a completed job. The error tracking shows nothing at all, because from the software's point of view, nothing went wrong.
I have spent some time on the ways to fix this ordinary bug which many systems have.
With conventional software, failure is loud. Something throws an exception, a request returns a 500, a queue backs up, an alert fires. The system tells you it is unhappy, and your job is to notice and respond.
AI systems behave differently. They are built to always produce an answer. A speech model asked to transcribe will transcribe something. A summariser handed an empty document will summarise it. A classifier showing an input it has never encountered will still return a category along with a confidence score. None of these are errors in any technical sense. They are outputs, delivered in exactly the same tone and shape as the correct ones.
The failure mode you have to design for, is not the crash. It has to be an accurate flow which can handle such errors appropriately.
Without verification, the first person to notice a result like that is usually a customer. With verification, the system notices first. We chose to make the system notice first.
I went looking for an upgraded feature which was a fairly simple one.
Here is the useful thing about human speech: it happens at a fairly predictable rate. People speak somewhere around 120 to 150 words per minute in ordinary conversation. Slower in a careful interview, faster in an excited one, but generally within that broad range. Which means a ten-minute recording that produces thirty words has given you an output which you can’t simply accept and needs to be flagged, that is not a person speaking quietly. It is probably the wrong model.
So we added a check that has nothing to do with AI at all. After transcription, we compare the number of words returned against the length of the audio, and if the result falls below a floor of roughly 24 words per minute, we treat the transcription with suspect rather than considering it complete.
//A plain arithmetic check on an AI output. No model involved.
function looksTooSparse(wordCount: number, audioSeconds: number): boolean { const minutes = Math.max(1, audioSeconds / 60); return wordCount < Math.max(10, minutes * 24); }
if (looksTooSparse(result.wordCount, audioSeconds)) { // Try other likely languages, keep whichever returns more speech. retryWithFallbackLanguages(); }
Two details in this check that really matter. The first is that the threshold is deliberately low. Normal speech runs at five times that rate, and we set the floor far beneath the slowest realistic conversation precisely so that it never flags a genuine transcript. A quiet recording, a hesitant speaker, long s in a therapy session: all of these clear the bar comfortably. Only true failures fall through it.
The second is the minimum word count. Without it, a five second voice note that correctly contains the single word "yes" would be treated as a failure. Short clips need a floor of their own. When a result does fall through, the system does not surface an error. It tries again in another language, keeps whichever attempt produces more speech, and only then completes the job. The retry list starts with Spanish, because users are more in the United States than other regions, and Spanish is by far the most common language after English amongst them.
The user never sees any of this. They see a transcript that reads correctly, and a small piece of arithmetic in the background is the reason why.
The safeguard runs silently, but the incident also changed the guidance we give people, because the best fix for a wrong guess is not needing to guess at all.
Always select the spoken language of your audio or video explicitly instead of relying on automatic detection. One deliberate click removes the largest source of avoidable mistakes.
When you want a translation or a summary in another language, choose that target language deliberately as well, so every step of the pipeline knows exactly what it has to do.
Add names, organisations and technical terms to the vocabulary field before up, because proper nouns are the words AI model misses first.
Whatever AI tool you use, the less you make it guess, the better its output is.
Every AI feature you ship has a plausible range of correct output, and you almost certainly know what it is. A summary of a two-thousand word document should not be nine words long. An extraction step that normally finds five to fifteen entities should be treated with suspicion when it finds zero. A translation should be roughly comparable in length to its source. The same applies to a classifier. If a category that historically receives three percent of traffic suddenly receives eighty percent, something upstream has changed, even though each individual answer, viewed on its own, still looks reasonable.
What is new is only where we point them: at the answers themselves, which arrive looking so finished that checking them feels unnecessary.
So the rule I offer, learnt through direct experience: **Do not treat a successful response as a successful result. Write down what a sound output should look like for each AI step you run, in numbers and follow the steps as recommended above.
Remember that the AI will not raise its hand and tell you it got something wrong. It does not know that it did. Making sure somebody knows is still your job.
Anubhav Jain is the founder of Trustample, an AI transcription platform. Everything above comes from building it.