In an earlier post I turned hundreds of hours of recorded Bible teaching into text. AI transcription is good, but not perfect — it mishears words, especially names and rare terms. So the obvious next step was to ask a smart language model to clean up the mistakes. These models have basically read the whole Bible, so I figured fixing a few scripture typos would be easy for them.

It wasn’t. And the way it failed taught me something that goes well beyond transcripts — to anyone using AI to correct text against a trusted source.

The model didn’t just miss errors. It made them. It confidently “corrected” a word that was already right. And the harder part was that the source itself isn’t consistent. The same name is spelled two different ways, depending on which book you’re in. The model’s habit of making everything neat and consistent was exactly what I had to work against.

The Correction That Was Wrong

Here’s the moment I noticed. A transcript mentioned a Bible figure — in English we’d write the name Uriah (Uriah the Hittite, from the David and Bathsheba story). The transcription had it spelled correctly for that passage. But when I ran the text through the model to fix typos, it “corrected” the spelling to a different form.

I only caught it because I happened to know the passage. And when I looked closer, I found the tricky part.

In the Korean Bible, that one name is spelled two different ways, depending on the book. It appears one way in the Gospel of Matthew and in Second Kings, and a different way in Second Samuel. Same person. Same Bible. Two spellings, decided by which book you’re quoting.

So there’s no single “correct” spelling to force. The model, going by its general sense of the name, had flattened a real, on-purpose difference — and made an error because it tried to be consistent.

Why the Obvious Fixes All Fail

Once I understood the problem, I tried the obvious solutions in my head, and watched each one fall apart:

  • “Just trust the model’s knowledge.” That’s what caused the error. The model leans toward one spelling and overwrites the cases that are meant to differ.
  • “Make a rule: always use spelling A.” That breaks every passage that’s meant to use spelling B. A simple find-and-replace can’t tell Second Samuel from Matthew.
  • “Just give it the right chapter as a reference.” Tempting, but it fails for a quiet reason: these are teaching recordings. A single lecture moves all over the Bible — a talk on one chapter quotes a dozen others. There is no one “right chapter.” The reference has to be everything.
  • “Build a dictionary of correct spellings.” Can’t work, because the right answer depends on context — which book is being quoted at that moment — not on the word by itself.

Every shortcut assumes the answer lives in a rule. It doesn’t. It lives in the source text.

The Fix: Make the Model Follow a Source of Truth

The fix was to stop letting the model lean on its own memory, and make it follow the trusted source instead.

The shape of it:

  1. Give it the full source text as a reference. Not the chapter — the whole thing. (Use a source text you have the right to use; the technique is the point here, not any particular text.)
  2. A first pass cleans up obvious transcription noise — mishearings, broken punctuation — with a capable model and a careful prompt.
  3. A second pass, tied to the source, does the final correction against the reference text itself, so names and quotes match the source exactly — including where the source spells the same name two ways in two books.

The key instruction to the model is almost a philosophy: don’t normalize; follow the source. Where the source is inconsistent, keep its inconsistency. The trusted text is trusted even in its odd spots, and the job is to match it, not to improve it.

One thing I didn’t expect: once I tied the correction to the real source, I could throw away the special-case rules. I’d started out building fragile exceptions (“keep this one name as-is”). The moment the model followed the source text, those crutches weren’t needed. The source decided.

Why This Goes Beyond Scripture

I want to lift this out of the religious details, because the lesson is general and I wish I’d understood it sooner.

Any time you ask an AI to correct text against a trusted reference — legal citations, brand and product names, medical terms, code names, a style guide, a person’s own spelling of their name — you’re up against the same habit. The model wants to make things consistent and normal. But trusted sources are full of on-purpose odd spots: the brand that’s lowercase by choice, the law cited in an unusual form, the name spelled “wrong” on purpose.

If you let the model use its own knowledge, it will quietly smooth those edges off and call it a fix. The cure is the same every time:

  • Give it the source of truth, not its own memory.
  • Tell it to follow the source, not to normalize.
  • Give it the whole reference, because you can’t predict which part a passage will touch.

That’s source-based correction in one line: the answer isn’t in the model, it’s in the source, and the model’s job is to look it up, not to remember it.

The Human Part, Again

There’s a thread running through this series, and this is another piece of it. Back in the post on real prompts, the AI was confidently wrong about a count, and knowing my own files caught it. Here it was confidently wrong about a spelling, and again it took a human who knew the passage to notice.

The machine did the work of correcting thousands of lines across hundreds of files — work I could never do by hand. But it couldn’t be trusted to know when it was wrong. That judgment, and the choice to tie it to a source of truth, was mine. For a project meant to keep an eighty-year-old teacher’s words exactly right, “close enough” wasn’t close enough.

If you’re building something where the text has to be exactly right, please subscribe — the next posts get into the bugs that taught me the most.

Key Takeaways

  • AI transcription leaves errors, but asking a model to fix them from its own knowledge can make new ones.
  • Trusted sources are inconsistent on purpose — the same name was spelled two ways in two books — and a model’s habit of “normalizing” turns those differences into mistakes.
  • Rules, dictionaries, and “just the right chapter” all fail; the answer lives in the full source text, not a shortcut.
  • The fix is source-based correction: give it the whole source of truth, and tell it to follow the source, not normalize.
  • Tying it to the source let me delete every fragile special-case rule — the source decided.
  • This applies anywhere text must match an authority exactly: law, brands, medicine, code, names.