I almost sent a client an email that opened “Dear Malice.” Her name is Melissa. My dictation software had heard it wrong for the third time that week, and by then I'd stopped reading closely — which is exactly how these things slip through. That near-miss is a big part of why I ended up building a dictation tool of my own.

Here's the thing nobody warns you about when you start dictating instead of typing: the software will nail a long, comma-laden sentence about quarterly forecasting and then fall flat on its face over a four-letter name it has heard from you a hundred times. It's maddening. And despite what you might assume at 6pm on a Friday, it is not your accent, your microphone, or the way you say your colleague's name.

It's not you — it's how the machine guesses

Speech recognition doesn't really "hear" letters and write them down. It listens to the sound, then predicts the most likely sequence of words that would produce that sound, heavily weighted by how common those words are in ordinary English. That last part is the whole problem. When you say "Melissa," the model is quietly holding a little contest between "Melissa," "malice," "a list," and a few others — and it has seen the word "malice" roughly a million more times than it has seen your friend.

So the more ordinary a name sounds, the more it gets swallowed by a common word. And the more unusual or local the name is — Siobhan, Nguyen, Xero, Kubernetes, your firm's internal project codename — the worse it gets, because the model has almost no memory of it to lean on. It isn't being careless. It's doing exactly what it was built to do: bet on the common word. Names are where that bet goes wrong.

The fixes everyone tries first (and why they don't stick)

I tried all of them, in roughly this order, over about two years:

Enunciate more. Slow down, hit every syllable. It helps a little — and it quietly defeats the entire point, which was to be faster than typing.
Spell it out loud. “Capital M, E, L…” Works, sort of, but it shatters your train of thought, and you have to do it every single time the name comes up.
Use the cloud tool's “custom vocabulary.” You add the word, it behaves for a week, then some update or some change of context rolls around and you're right back to “malice.”
Just fix it by hand afterwards. Perfectly fine — until you notice you're doing it fifty times a day and you've become a very expensive proofreader for your own dictation.

The common thread is that none of them remember. You patiently teach the tool the same lesson on Monday, and by Thursday it has quietly forgotten and you're teaching it again. After a while you stop trusting it, which means you go back to reading every line like a hawk, which means the speed you were chasing is gone.

What actually worked: a tool with a memory

The fix that finally stuck is almost embarrassingly obvious once you say it out loud. The tool needs to do two things it mostly doesn't: know your names before you start, and never un-learn a correction.

The first one is about seeding. The fifty names you say most aren't a mystery — they're sitting in your contacts and the people you email every day. If the tool starts already knowing them, most of the mistakes never happen in the first place. It's strange that this isn't the default; the names you dictate are the ones you already have written down somewhere.

The second one is about permanence, and it's the part that changed everything for me. When you correct "malice" to "Melissa" once, that shouldn't be a polite suggestion the software slowly forgets. It should become a rule. The next time you say her name, it comes out Melissa, and it stays Melissa in a month. And once a tool is keeping that kind of memory, it stops being only about spelling — give it a few weeks and it starts to pick up how you actually phrase things, how long your emails run, the way you sign off. The draft starts sounding like you wrote it, because in a sense it learned to.

Why this has to happen on your own computer

Here's the uncomfortable bit, and the reason I stopped using cloud tools for this. The reason they're bad at learning your names isn't laziness. It's that genuinely learning you means keeping a detailed, personal record of your contacts, your jargon, your turns of phrase, the way you talk. That is about the most sensitive profile you could hand to a server in another country — and no privacy policy makes me comfortable about a running transcript of everyone I've ever emailed living on someone else's machine.

So the honest way to build a tool that learns you deeply is to keep the learning on your own computer, where it's free to be as personal as it likes precisely because it never leaves. That's the whole reason I went fully on-device — not as a slogan for a landing page, but because it's the only setup where a dictation tool can learn your entire world without that being a liability the moment there's a breach.

The honest limitation

I'm not going to pretend it's magic. The very first time you say a brand-new name, it will probably still get it wrong, because no model on earth can spell a word it has never once encountered. The difference is entirely in what happens next. Wrong once, right forever: you fix it a single time, and then you genuinely never think about it again. After a couple of weeks, the handful of names and terms you use constantly simply stop coming out as nonsense, and you get to go back to trusting the text instead of auditing it.

If you're fighting the same thing

If you dictate for a living and you're tired of "Dear Malice," the short version of everything I learned is this. Add your names before you need them, not after. Choose a tool that treats a correction as a permanent rule and not a hint it'll forget. And if the names you're dictating are the kind you can't afford to leak — clients, patients, interview participants, an unannounced product — use something that keeps that list on your own machine. That's two years of quiet irritation compressed into three sentences. I hope it saves you the two years.

Why voice dictation keeps getting names wrong — and what finally fixed it