Say What I Said: Dictation Without the AI Rewrite

There's a complaint about modern dictation tools that sounds paradoxical until you've lived it: the transcription was fine — it's what happened after the transcription that ruined it. Across the category of AI-"enhanced" dictation, including among Wispr Flow and Superwhisper users, the same pattern keeps surfacing: you said one thing, and the tool delivered a polished, confident, slightly different thing. A qualifier quietly dropped. A hedge removed. A sentence restructured into something you'd never say. And in the worst version of the pattern — the one that makes people quit a tool on the spot — the meaning flips. "Don't deploy until the tests pass" comes out the other end as an instruction about deploying, minus the don't.

For casual dictation this is an annoyance. For the way I actually use dictation — feeding prompts to Claude Code, the workflow from driving Claude Code with your voice — it's poison. A coding agent takes your words as a specification. It doesn't know your dictation tool paraphrased you. If the qualifier that made the instruction safe got smoothed away between your mouth and the terminal, the agent will cheerfully execute the smoothed version. Precision is the entire point of a prompt, and an AI rewrite layer is a machine for removing precision while making the result look more deliberate.

Why do AI dictation tools rewrite what you said?

The category-level answer isn't that anyone set out to distort speech. It's that "clean up this transcription" is a genuinely appealing feature, and the obvious way to build it is to run the raw transcript through a language model.

Raw speech is messy — fillers, false starts, repeated words, missing punctuation. An LLM asked to tidy that up produces beautiful output. The trouble is that a language model doesn't edit, in the way a human copyeditor removing "um" edits. It regenerates. The output is a new text that the model considers a good version of your input, and "good" is where your intent leaks out. Models trained toward helpfulness and fluency have opinions: hedges look like noise, qualifiers look like clutter, an awkward-but-precise phrasing looks like something to improve. Most of the time the rewrite is harmless. But it's probabilistic, and you can't tell from the output which sentences were transcribed and which were composed. The polish is uniform; the fidelity isn't.

That's the deep problem with LLM-polish pipelines: they fail silently and confidently. A speech recognizer that mishears you usually produces something visibly wrong. A rewrite layer that betrays you produces something visibly right — grammatical, plausible, wearing your voice — which is exactly why the reversed "don't deploy" gets sent instead of caught.

Literal by default

Keebye's position is simple: what the speech-to-text model heard is what lands at your cursor. By default, no language model sits between the transcription and your terminal composing a better version of you — the default polish stage is a short list of deterministic rules, and that's it.

That's a deliberate bet, and it comes from the vibecoding use case. When your dictation is the control channel for coding agents, the tool's job is transport, not authorship. You are the writer; the agent is the audience; the dictation layer should have no opinions.

There is an LLM polish in Keebye — I'll get to it — but it's opt-in, it runs entirely on your machine, and it operates under a guard whose whole job is making the silent-paraphrase failure mode structurally impossible. The default remains rules.

So what does the cleanup actually do?

Literal doesn't have to mean raw. Keebye ships an optional cleanup pass — enhancement, on by default, and overridable per app — but it's rule-based, not a model, and the complete list of what it does fits in one paragraph:

It strips standalone filler words (um, uh, erm, you know). It collapses immediate word repeats — "the the" becomes "the". It collapses whitespace. It capitalizes the first letter, and it adds a terminal period if you didn't end with one. That's the whole list. Deterministic rules, the same input producing the same output every time, and nothing in the list that can touch your meaning: no rule removes a don't, reorders a clause, or substitutes a synonym.

Before cleanup runs, your dictionary substitutions apply — user-defined replacements for the jargon and proper nouns speech models mangle, so "pnpm" and your module names arrive spelled the way your codebase spells them.

And if even the rule-based pass is more intervention than you want, turn enhancement off and the text is verbatim: fillers, repeats, and all. For some contexts — quoting someone, dictating into a field where the trailing period breaks things — verbatim is correct, and the per-app override means you can have it both ways.

The opt-in polish, and the fidelity guard around it

Now the LLM I promised to get to. For people who do want smarter cleanup, Keebye offers an optional polish mode (polish_mode set to local_llm): a small Qwen3 model running on-device via llama.cpp, Metal-accelerated, nothing sent anywhere. Its instructions are the narrow version of polish — fix punctuation and capitalization, remove fillers, keep the user's exact words, language, and meaning, preserve code and filenames verbatim. Generation is deterministic (greedy sampling, same input → same output) and capped; if the model stalls past a two-second deadline, its output is abandoned.

But instructions are hopes, and this article exists because hopes aren't guarantees. So every LLM-polished result passes through a fidelity guard before it can touch your cursor. The output must retain at least 50% of the original transcription's words. It must not balloon — anything past roughly twice the original length (plus four words) fails. Runaway repetition is detected. If the polished result fails any of those checks — hallucination, paraphrase drift, prompt regurgitation, a repetition loop — Keebye discards it and falls back to the rule-based cleanup instead.

The guarantee that buys is the one this whole article is about: an AI rewrite can never silently replace what you said, even when you've opted into AI polish. The model's output either stays demonstrably close to your original words, or it never ships — the worst case is that you silently get the boring deterministic cleanup. The failure mode that makes people quit other tools — a confident paraphrase wearing your voice — is structurally blocked, not policy-blocked.

The honest limits

Literal means literal. If you ramble, your rambling lands — even the opt-in polish is instructed and guarded toward cleanup, not composition, so Keebye will not turn a meandering thought into a crisp instruction. The discipline of saying what you mean stays with you.

The rule-based cleanup is intentionally dumb. It removes "um"; it will not fix your grammar, restructure a run-on sentence, or notice that you contradicted yourself. Anything smarter would reintroduce the judgment calls this design exists to avoid.

And fidelity protects against rewriting, not misrecognition. If the speech model mishears "cache" as "cash", that error is faithfully preserved — the guard has no idea what you meant to say, only what was transcribed. Literal dictation moves the trust boundary to the STT model; it doesn't eliminate it. (Related: if your problem is the model transcribing in the wrong language entirely, that's a different failure with a different fix — pin your dictation language.)

Finally, the category framing: AI polish isn't a scam, and plenty of users genuinely prefer output that reads smoother than they speak. If that's you, other tools lean into it well, and our comparisons say so honestly — Keebye vs Wispr Flow and Keebye vs Superwhisper both include a real "when the other tool fits better" section.

Transport, not authorship

The deal Keebye offers is narrow on purpose: you speak, and your words — cleaned of fillers, never of meaning — land where your cursor is. When those words are prompts to an agent that will act on them literally, narrow is a feature. The most expensive thing a dictation tool can do to a developer isn't a typo. It's a fluent sentence you never said.

Keebye is in early access for macOS — start at Keebye. Dictate an instruction with a don't in it, and check what arrives. That test is the whole product.