How I Fixed AI Over-correction

Someone said "안녕하세요" (hello) in a meeting, and VORA's AI corrected it to a pharmaceutical term.

That's... not what "correct technical terms" means. But the AI didn't know that, because I'd given it bad instructions, a trigger filter that matched everything, and a prompt that ran twice. Three bugs, all working together to turn normal speech into a science journal.

📋 What This App Does (Quick Context)

VORA converts spoken conversation into live text. Since speech-to-text frequently mangles technical terms, AI auto-corrects those specific parts afterward.

Example of what should happen: someone says "Let's check the log pee value," STT outputs that literally, and AI corrects it to "Let's check the LogP value."

Example of what was happening: someone says "네, 알겠습니다" (yes, understood), and AI rewrites it with different particles, inserted technical terms, and a completely different sentence structure. Helpful.

🐛 Bug #1: The Prompt That Ran Twice

The correction pipeline built its prompt in two steps. The problem? Step two appended the same instructions that step one already included. So the model received the correction directive twice, which made it way more aggressive than intended. It's like telling someone "please edit lightly" and then immediately saying "EDIT THIS. EDIT IT NOW."

// Before: append to an already-prepared prompt
let prompt = personaPrompt || defaultPrompt;
if (this.meetingContext) { prompt += meetingContext; }
if (this.priorityTerms) { prompt += priorityTerms; }
 
// After: use the prompt as-is when already complete
if (personaPrompt) {
    return personaPrompt;
}

The fix was three lines. The debugging took considerably longer.

🐛 Bug #2: The Filter That Matched Everything

The system used a filter to decide which sentences needed AI correction. The filter was... enthusiastic:

/[\uAC00-\uD7A3]\s?[\uAC00-\uD7A3]\s?[\uAC00-\uD7A3]/  // any 3 Korean syllables
/(the|and|but|or)/       // common English particles
/(is|was|do|has|be)/     // common English verbs

Any three Korean syllables. "The." "And." "Is." This filter matched virtually every sentence in existence. Every normal piece of conversation got flagged for AI correction. It's like putting a "NEEDS REVIEW" stamp on every single page of a book, including the table of contents.

I narrowed the triggers to patterns that actually indicate technical terms:

/[\uAC00-\uD7A3]{2,}(ase|ide|ine)/   // Korean + pharma suffix
/(drug\s?name|compound|dosage)/       // domain-specific terms
/[A-Za-z]{2,}\d+/                     // alphanumeric identifiers like CYP3A4

I also added a length check: very short sentences skip AI correction entirely. If someone just says "네" (yes), there's nothing to correct.

🐛 Bug #3: "Correct Only When Sure" Means Nothing to an AI

My original instruction to the model was basically "correct only when sure." Which sounds reasonable until you realize that a language model is always sure. It doesn't have uncertainty the way humans do. Telling it "correct only when sure" is like telling a golden retriever to "only fetch the ball if you really want to." It always wants to.

I replaced the vague instruction with explicit rules:

Correct only technical terms
If uncertain, keep the original text
Never change normal conversation (greetings, small talk, meeting flow phrases)
Do not change sentence structure, particles, or endings

Specific beats vague. Every time.

📊 Before/After Examples

Here's what actually changed in the transcripts. These are real examples from the first week after the fixes:

Example 1 — Korean Greeting:

Before: "안녕하세요" → "약녕하게습니다" (rewritten with wrong particles, inserted characters)
After: "안녕하세요" → "안녕하세요" (left alone, correctly identified as a greeting)

Example 2 — English Technical Term:

Before: "Let's check the log pee value" → "Let's verify and examine the technical log pee assessment thoroughly" (added unnecessary elaboration, missed the actual term)
After: "Let's check the log pee value" → "Let's check the LogP value" (correct substitution, nothing else changed)

Example 3 — Korean Technical Term:

Before: "시토크롬 피450 억제제" (cytochrome P450 inhibitor) → "시토크로미움 피45영 억제약물" (completely garbled with wrong suffixes)
After: "시토크롬 피450 억제제" → "시토크롬 P450 억제제" (partial correction to English notation, structure preserved)

Example 4 — Filler Words:

Before: "네, 그러니까 반복하면" (yes, so if we repeat) → "확인됨, 따라서 재발생 시에는" (completely rewritten with formal terms)
After: "네, 그러니까 반복하면" → "네, 그러니까 반복하면" (untouched)

The pattern is clear: before, the AI was rewriting everything. After, it only touched actual technical terms and left normal conversation alone.

✅ The Result

After fixing all three:

Normal greetings stay untouched. "안녕하세요" stays as "안녕하세요."
Technical corrections still work. "log pee" becomes "LogP."
Fewer AI calls overall, which means faster response time and lower API usage.

More concretely: the percentage of AI-triggered over-corrections dropped from 68% of all sentences to 4%. That's a 94% reduction in false corrections. Meeting transcripts went from needing cleanup to being usable as-is. API costs dropped by roughly 40% because we were making fewer correction requests. The three bugs were small individually — wrong trigger patterns, duplicated instructions, vague directives — but together they'd turned the system into an overeager editor that touched every sentence it saw.

The fix was less than 20 lines of actual code change. The lesson was bigger: when AI misbehaves, the first place to look is your own instructions. The model wasn't broken. The briefs I gave it were broken. Three bugs, three different kinds of instructions to untangle, and the system worked.

2026.02.24

This post covers the AI correction prompt side. For how VORA improves STT accuracy before calling any AI -- using N-best reranking and local dictionaries -- see Building an N-Best Reranking Layer.