Podcast Transcript Errors: Fix Names and Jargon

Automatic transcription is good at ordinary speech and bad at the words that matter most on a podcast: guest names, company names, product names, and the jargon of your niche. "Dana Ortiz" becomes "Dana Ortis." "Kubernetes" becomes "Cubernetes." Every one of those errors then travels into your search results, your show notes, and any AI tool that reads the transcript.

The fix is not to proofread every transcript from scratch. It is to build a glossary once, use it before transcription and after it, and add to it whenever you catch a miss. This post shows how, with a short script that applies your glossary to a whole folder of transcripts.

GoTranscript's guide to fixing Whisper output makes the same core point: keep the glossary in one shared place "so editors and reviewers use the same spellings." What follows is the version for a solo host who wants it automated.

Why a few wrong words cause real problems

• Search breaks. If you search your archive for a guest's name and the transcript spells it three different ways, you miss episodes.
• Show notes inherit the error. An AI model summarizing a transcript will copy a misspelled name faithfully, and sometimes propagate it.
• Guests notice. A wrong spelling of a guest's name in the show notes is the kind of mistake that lands in a reply email.

Step 1: Start the glossary before you record

The cheapest time to get spellings right is when you book the guest. Ask for the exact spelling of their name, their company, and any terms they expect to use. If your show has recurring terms, such as your show name, a newsletter name, or a framework you invented, those belong in the list from the start.

Keep it as a plain two-column CSV file, one row per correction, with the wrong version first:

# wrong,right
Dana Ortis,Dana Ortiz
Cubernetes,Kubernetes
Whisper X,WhisperX

Lines that start with # are comments. The file grows over time, and it is worth versioning next to your transcripts.

Step 2: Give the transcriber a hint

Whisper accepts an initial prompt: a short piece of text that nudges the model toward spellings it should expect. With OpenAI's open-source command line tool:

whisper episode.mp3 --model small --language en \
  --initial_prompt "Guest: Dana Ortiz. Terms: Kubernetes, WhisperX, Spoke and Sprocket." \
  --output_format txt --output_dir transcripts

Treat this as a hint, not a guarantee. It helps with names the model would otherwise have to guess, and it does not always work, so keep the prompt short, list only the names and terms for this episode, and check the result. OpenAI's own comparison of the prompt against post-processing found the post-processing pass more reliable, and the prompt is capped at a few hundred characters. That is why the rest of this post leans on the glossary and the script, with the prompt as a bonus.

Hosted transcription services offer similar features under different names, usually a custom vocabulary or word boost list. If you use one, feed it the same glossary.

Step 3: Find what the transcriber got wrong

You do not need to read every line. Proper nouns are where the errors cluster, so list the capitalized words and phrases and scan them for oddities:

grep -ohE "\b[A-Z][a-z]+( [A-Z][a-z]+)*\b" transcripts/*.txt | sort | uniq -c | sort -rn | head -50

This prints the fifty most common capitalized terms. A name that appears in two spellings shows up as two separate lines with different counts, which makes the misspelling easy to spot. Sentence-initial words such as "The" and "So" will appear as noise, and you can ignore them.

Add each wrong spelling you find to the glossary, paired with the right one.

Step 4: Apply the glossary to every transcript

This script reads a folder of transcripts and your glossary, replaces whole-word matches ignoring case, writes cleaned copies to a new folder, and tells you what it changed:

#!/usr/bin/env python3
"""Apply a show glossary (wrong,right) to every transcript and report what changed."""
import csv
import re
import sys
from pathlib import Path


def load_glossary(path):
    with open(path, newline="", encoding="utf-8") as f:
        rows = [row for row in csv.reader(f) if len(row) >= 2 and not row[0].startswith("#")]
    return [(wrong.strip(), right.strip()) for wrong, right, *_ in rows if wrong.strip()]


def main(folder, glossary_file, out_folder="cleaned"):
    glossary = load_glossary(glossary_file)
    Path(out_folder).mkdir(exist_ok=True)
    for path in sorted(Path(folder).glob("*.txt")):
        text = path.read_text(encoding="utf-8", errors="ignore")
        changes = []
        for wrong, right in glossary:
            text, count = re.subn(rf"\b{re.escape(wrong)}\b", right, text, flags=re.IGNORECASE)
            if count:
                changes.append(f"{wrong} -> {right} x{count}")
        (Path(out_folder) / path.name).write_text(text, encoding="utf-8")
        print(f"{path.name}: {', '.join(changes) or 'no changes'}")


if __name__ == "__main__":
    if len(sys.argv) not in (3, 4):
        sys.exit("usage: fix_names.py <transcript-folder> <glossary.csv> [output-folder]")
    main(*sys.argv[1:])

Run it with python3 fix_names.py transcripts glossary.csv cleaned. Output looks like this:

0001.txt: Dana Ortis -> Dana Ortiz x2, Cubernetes -> Kubernetes x1
0002.txt: no changes

The original transcripts are untouched, so a bad glossary entry never destroys anything. Whole-word matching means a glossary row for "Ortis" will not rewrite the middle of another word, but it will change every standalone "Ortis." Check that a wrong spelling is not also a real word before you add it.

Step 5: Label who is speaking

Plain Whisper output does not say who is talking. For most tasks that is fine. For the ones that need the host's words alone, such as measuring your writing style, it matters. Tools built on top of Whisper, WhisperX for example, add speaker labels. If you use one, label the host and guest consistently in every file, and note which label is which so scripts can filter by it.

Step 6: Keep feeding the glossary

Each time you correct a transcript by hand, add the correction to the glossary before you close the file. After a handful of episodes the glossary catches most of what you would have fixed manually. The same file is also useful outside transcription. Paste it into your AI tool's context, under a heading like "Spellings," so show notes use the right names from the start.

What a glossary will not fix

It fixes errors you have already seen. A new guest with an unusual name is still a risk on their first episode, which is why the pre-recording spelling request matters. It also cannot fix words the transcriber heard as different real words, such as a name that comes out as an ordinary phrase, because those are hard to find with a capitalized-word scan. For those, search the transcript for the guest's name and read the surrounding lines.

Checklist

• Guest name, company, and key terms collected before recording
• glossary.csv created and stored with the transcripts
• Short --initial_prompt used for each episode
• Capitalized-word scan run on each new transcript
• fix_names.py run, and the change list skimmed
• Every manual correction added back to the glossary