building Shepit, an AI dictation app that turns speech into text

long story short

Dictation promises the fastest route from a thought to the screen. You hold a key, speak and release, and the words should simply land where your cursor is. In practice, the gap between that promise and daily use is wide. The text arrives in the wrong language, part of a long recording quietly goes missing, or you sit waiting for a transcript while the thought you wanted to capture fades.

Oleksij Rak, Rebbix co-founder and CEO and an engineer with decades of experience, ran into these problems himself. He dictates a lot, often in long stretches with pauses to think. The tools he tried either handled short English phrases well and stumbled on everything else, or they worked but made him edit afterwards almost as long as typing would have taken.

So he built his own. Shepit is a dictation app for Mac that works in any text field: hold a key, speak, release, and punctuated text appears at the cursor, even after an hour of speaking. Oleksij built it hands-on, from the speech pipeline to the tools behind the product blog, working with AI coding agents throughout. What started as a fix for his own dictation became a public product with a free tier and paid plans.

the problem

Speech-to-text looks like a solved problem: send audio to an API, get text back. The first version of Shepit worked exactly that way, and real daily use quickly exposed where it broke.

• Wrong language. At the beginning, the algorithm failed to identify the language correctly, even though every request specified Ukrainian. In tests, 8 of 76 dictations switched language on the original engine.
• Text from silence. An accidental tap of the hotkey on three seconds of room noise returned the app's own instruction prompt, which then landed in whatever field had focus.
• Lost speech reported as success. One fifteen-minute recording came back with nearly eight minutes missing from the middle. Only 36% of the words survived, and the API still returned HTTP 200 with no error.
• Waiting grew with every minute. Transcription only started after the user stopped talking, so each extra minute spoken added about a second and a half to the wait. 
• Heavy uploads. A minute of raw audio weighed almost 2 MB. In a load test, one server instance failed 92% of requests at just 15 simultaneous users.
• Paying for silence. Almost a quarter of recorded audio turned out to be pauses between phrases, and transcription engines bill for those seconds too.

‍

"Seconds saved are worth nothing if a word goes missing. Hold, speak, release: every word has to land."

Oleksij Rak, Co-founder and CEO at Rebbix

‍

So, how do you build dictation that keeps every word, returns text in seconds, whatever the length, and doesn't charge you to transcribe silence?

what we built

Oleksij rebuilt the path from microphone to text field around one rule: the user should never notice the complex processing behind it. Shepit is a system-wide dictation app for macOS backed by a speech pipeline that picks the transcription engine for each dictation, works on long recordings while the user is still talking, and sends the engine only the audio that matters.

The interface stays minimal. A small capsule appears on screen while the key is held, its bars rising and falling with the voice. Everything else happens in the background.

Core capabilities include:

• system-wide dictation: works in any Mac text field through a hotkey. Hold mode records for up to an hour, toggle mode starts and stops with a press.
• long dictations in pieces: recordings are cut at natural pauses and each finished piece is transcribed while the user keeps speaking, so only the final stretch remains after release.
• silence trimming: a dedicated voice-aware detector shortens pauses longer than a second to one second before upload. Very noisy pieces are sent whole so no word gets cut.
• on-device compression: audio is encoded on the Mac before upload, about 8 times smaller than raw, which keeps the server fast under load.
• personal dictionary: names and jargon are sent to the engine as hints. Routing takes the dictionary's cost into account, because some engines bill for it on every request.
• optional AI cleanup: removes filler words, fixes punctuation, and smooths self-corrections, across roughly 100 languages.
• safe retries: if a piece fails, only the pieces without text are re-sent, while everything already returned is kept.
• adaptive recording indicator: the on-screen capsule learns the room's background noise, so it reacts to the voice rather than the ventilation sounds.

how it works

A single dictation in Shepit goes through these steps:

1. The user holds the hotkey and speaks. The on-screen capsule follows the voice.
2. The Mac records and compresses the audio as it comes in.
3. Once a piece passes one minute, the app waits for the first full-second pause and cuts in the middle of it. If no pause arrives by two minutes, it looks back for the best available gap.
4. Each finished piece is trimmed of long pauses and uploaded while the user keeps talking.
5. The server sends the piece to the selected engine, together with the language code and the user's dictionary.
6. On release, only the last piece is left to transcribe. The returned text is joined in recording order.
7. If the AI cleanup feature is on, the full text is polished, then pasted into the focused field.