How a Translation Agency Can Tame Glossary Drift and Proofreading Rework with Claude Code

It was a Friday evening when the complaint landed on a manual we had already delivered. “The product name doesn’t match the previous issue, does it?”

I checked, and sure enough, it didn’t. Last time it was “Customer Account,” this time it was “User Account.” The glossary clearly said “Customer Account,” but the translator who rushed the job to hit the deadline missed it, and the proofreader missed it too. In my three years running jobs at a translation agency, this is the single most common kind of rework I see.

It’s not about pointing fingers. The glossary is 200 rows in an Excel file. It grows a little with every project. Translators are buried under deadlines, proofreaders are reading every line by eye. Stopping every single terminology inconsistency on human attention alone just isn’t realistic anymore.

So I tried handing Claude Code the job of being a “first-pass terminology filter.” Keep the judgment with the humans, but knock out the mistakes a machine can catch before anyone reads a word. It worked better than I expected, so here’s the playbook from the seat of a translation-agency coordinator.

Key takeaways

• Terminology drift and inconsistent word choices are mostly “machine-detectable mistakes,” and a Claude Code first pass catches the bulk of them.
• Don’t feed the glossary as raw Excel. Convert it to CSV or plain text and hand it to the AI as a “list of rules” to lift accuracy.
• Split your draft-and-proofread flow into “what the AI flags” vs. “what a human decides,” and the rework drops.
• Source files and glossaries contain proper nouns and unreleased information, so controlling what you send is non-negotiable.
• Roughly 30 to 60 minutes of pre-proofreading work per project; run 10 projects a month and you free up several to a dozen-plus hours.

What’s actually happening on the agency floor

Let me set the scene first. This article is written for the coordinator who runs jobs at a translation agency. Rather than translating everything yourself, you stand between the translator and the proofreader, manage the glossary, and get squeezed between deadlines and quality. You have little to no programming experience, maybe you’ve poked at a spreadsheet macro once or twice.

The typical workflow at a translation agency looks roughly like this:

1. Receive the source text, past translations, and the glossary from the client.
2. Ask a translator to produce a first draft.
3. A proofreader (checker) reviews the translated text.
4. The coordinator does a final check and delivers.

Where does the rework creep in? In my experience, almost always between steps 2 and 3.

• The translator didn’t use the term from the glossary (terminology drift).
• A number or unit slipped versus the source (“3.5 kg” becomes “3.5 g,” and so on).
• A dropped sentence (a line in the source that simply doesn’t exist in the translation).
• Bracket styles or capitalization that don’t match the project’s rules.

Every one of these is the kind of mistake you’d catch “if you just read it.” But when a human eye is tracking the whole document, the longer the job, the more slips through. What the proofreader misses goes to the coordinator, and the last stop is a post-delivery complaint. That “time a human spends hunting for mistakes a machine should have caught” is the translation agency’s hidden cost.

What to delegate to the AI, and what a human must always decide

If you don’t draw this line up front, you’ll have an accident. Claude Code is smart, but you must never let it make the final call on translation quality. Here’s the boundary.

Step	Delegate to Claude Code	A human (proofreader/coordinator) decides
Terminology check	Cross-check the glossary against the translation and list every mismatch	Whether the mismatch is an error or a context-driven exception
Style drift	Pull out inconsistencies in brackets, spacing, and capitalization	The final wording that matches client preference
Numbers & units	Detect differences between source and translated figures	Whether the unit conversion and the meaning are correct
Dropped lines	Report a gap between source sentence count and translation sentence count	Whether a merge or split was intentional
Translation quality	(Don’t delegate. Draft assistance at most.)	Final call on naturalness, tone, and mistranslation

The point is to never let the AI “decide what’s correct.” All the AI does is stick a sticky note that says “this looks off.” Whether to peel it off or leave it is a human call. Break that division of labor and you get the accident where the AI’s misjudgment ships straight to the client.

If you’re unsure how to phrase the boundaries, the prompt design in claude-code-prompt-engineering-advanced is a good reference. Leave the instruction vague and the AI will happily “fix” things on its own, so the trick is to specify the output format right down to the table columns.

Use case 1: Cross-checking against the glossary

This is the one that pays off the most. You hand over the glossary and the translation, and have the AI return only the mismatches as a table.

First, turn the glossary from Excel into CSV. Rather than feeding the AI raw Excel, a three-column text file of “source term, target term, note” is far easier for it to read as a set of rules. The setup prompt looks like this.

You are a proofreading assistant at a translation agency.
Following the glossary below, flag ONLY the terminology mismatches in the translation.

# Rules
- Report only places where the glossary's "target term" was not used.
- Do not judge whether it is a contextual paraphrase; list every mechanical mismatch.
- Do not fix anything. Flag only.
- Output as a table: | Line | Source term | Expected target | Actual target |

# Glossary (source term, target term, note)
customer account, Customer Account, common to all projects
sign in, log in, this client standardizes on "log in"
delete, delete, do not use "erase"

# Translation
(paste the translated text here)

What comes back is not a “fix” but a “list of mismatches.” The proofreader reads down the table and decides only whether to correct each one. That’s dramatically faster than re-reading the entire document.

Before we introduced this, the proofreader kept the Excel glossary open in a separate window and cross-checked the translation by eye. After, the task became “review the sticky notes the AI left.” Same word, “review,” but starting from zero versus judging a list of candidates is a completely different mental load.

Use case 2: A pre-draft checklist

Right before handing work to a translator, or right after a draft comes back, run one machine check. Use this checklist as is.

• Is the glossary’s target term used in every place?
• Do the numbers and units match between source and translation?
• Are there any dropped lines (a source sentence with no counterpart in the translation)?
• Do bracket styles and spacing follow the project rules?
• Do product names, personal names, and proper nouns match past translations?
• Are any banned phrases (wording the client dislikes) mixed in?

Run this check at the draft stage and fewer mistakes reach the proofreader. The proofreader can then work on the assumption that “the machine-catchable parts are done” and focus on naturalness and mistranslation, the judgment only a human can make.

If you do let the AI help with the draft itself, don’t hand over the whole document at once. Keep it to “a rough draft that respects past translations and the glossary.” A human finishes the final version. If your team is brand new to AI, read claude-code-for-non-engineers first to get a feel for how far to delegate.

Use case 3: A periodic terminology stocktake

When a project runs long, the glossary itself goes stale. Changes like “it used to be ‘delete,’ but starting this quarter ‘remove’ is fine” get passed around verbally and never make it into the glossary, and the floor gets confused.

So once a month, feed past deliverables to the AI in bulk and surface “places where the same concept is mapped to multiple target terms.” That’s how you find the glossary maintenance you’ve been missing. If you keep the project’s shared rules in a single file, the AI references them every time, so consolidating each project’s conventions into one file the claude-md-best-practices way makes the operation much easier to run.

A copy-paste prompt template

Here’s a general-purpose template for the first-pass proofreading check. Just swap in your project name and glossary.

# Role
As the first-pass proofreading checker at a translation agency,
report ONLY mistakes that can be detected mechanically.

# Inputs
- Glossary (source term, target term)
- Source text
- Translation

# What to do (in this order)
1. Extract terminology mismatches.
2. Extract differences in numbers and units versus the source.
3. Report suspected dropped lines (source sentence count > translation sentence count).
4. Extract bracket and spacing inconsistencies.

# What NOT to do
- Do not rewrite the translation.
- Do not evaluate translation quality.
- Do not make exception judgments (humans decide those).

# Output format
## Terminology mismatches
| Location | Expected target | Actual |
## Numbers & units
| Source | Translation | Difference |
## Suspected dropped lines
- (location)
## Style inconsistencies
- (location)
If there are no issues, write "No findings" in each section.

A runnable check script: catch number mismatches by machine

Before you hand anything to the AI, knock out the “number slips” that a machine can detect for certain. That lowers your dependence on the AI and is safer. Here’s a small script that runs on Node.js. Give it the source and translation as text, and it lists any numbers that appear on only one side.

import { readFile } from "node:fs/promises";

// Take the source and translation file paths as command-line arguments.
const [srcPath, tgtPath] = process.argv.slice(2);
if (!srcPath || !tgtPath) {
  console.error("Usage: node check-numbers.mjs source.txt target.txt");
  process.exit(1);
}

const src = await readFile(srcPath, "utf8");
const tgt = await readFile(tgtPath, "utf8");

// Pick up every number (including decimals and comma separators).
const pick = (text) => (text.match(/\d[\d,.]*/g) || []).map((n) => n.replace(/,/g, ""));

const srcNums = pick(src);
const tgtNums = pick(tgt);

// Output the numbers that appear on only one side as the diff.
const diff = (a, b) => a.filter((n) => !b.includes(n));

const onlyInSrc = diff(srcNums, tgtNums);
const onlyInTgt = diff(tgtNums, srcNums);

console.log("Numbers only in source:", onlyInSrc.length ? onlyInSrc.join(", ") : "none");
console.log("Numbers only in target:", onlyInTgt.length ? onlyInTgt.join(", ") : "none");

if (onlyInSrc.length || onlyInTgt.length) {
  console.log("-> A number mismatch is suspected. Check the relevant spots.");
  process.exit(2);
}
console.log("-> The numbers match.");

You just save it and run it.

node check-numbers.mjs source.txt target.txt

It’s not a perfect detector. Reorder the words and you’ll get false positives. But a fatal slip like “3.5 disappeared from the translation” is found faster and more reliably than by eye. The trick is to put these deterministic checks first, before you lean on the AI’s judgment. If this is your first time with Claude Code, set up your environment with the steps in claude-code-getting-started-guide before you try it.

Security and personal information

For a translation agency, this is life or death. Source files contain unreleased product information, contracts, and personal names. Mishandle it and instead of efficiency you lose trust.

• Always confirm whether your non-disclosure agreement (NDA) with the client permits sending data to an external AI service.
• For projects without permission, replace proper nouns and figures with dummies before you run the check.
• Mask personal information (names, addresses, contact details) before checking.
• Choose a setting or contract form where the data you send is not used for training.
• Record “AI use allowed / not allowed” per project in a management sheet and share it across coordinators.

When in doubt, “don’t send it” is the right answer. The glossary cross-check works perfectly well as a style-rule check even with proper nouns redacted. If you’re unsure about handling personal data, it’s worth confirming your practices against an authoritative source like the Information Commissioner’s Office guidance so you’re not stepping outside the lines.

A rough ROI estimate

This is a back-of-the-envelope figure, but let me share the feel of it. For proofreading one mid-size manual translation (roughly 10,000 words of source), the time a human spent on the pre-work of terminology matching and number checks used to be 30 to 60 minutes.

Hand that first-pass filter to the AI and the check script, and the pre-work shrinks to around 10 minutes. That’s a net 20 to 50 minutes saved. For an agency running 10 projects a month, that works out to several to a dozen-plus hours freed up every month.

With that reclaimed time, the proofreader can move to the judgment only a human can make, mistranslation and tone. It’s not just a time saving. The bigger win is shifting human attention to the final line of quality.

FAQ

Q. Is it bad to let the AI edit the translation directly? I don’t recommend it. Delegate the fixing too, and the AI’s misjudgments get baked straight into the translation, which actually increases your proofreading. Keep the division where the AI “flags only” and humans do the fixing.

Q. My glossary is over 500 rows. Can I send all of it? The realistic approach is to send only the part relevant to the project. Send all of it and accuracy drops. Splitting the glossary by project genre makes it much easier to operate.

Q. How is this different from a machine-translation engine? Different roles. Machine translation generates the translated text; what I described here is a first-pass filter that inspects the generated translation. Combine both and you cover both ends, generation and inspection.

Q. Won’t this put proofreaders out of work? The opposite. They’re freed from hunting for machine-catchable mistakes and can focus on mistranslation and nuance, the judgment only a human can make. It’s about shifting time toward the higher-value steps.

Q. We want to roll this out company-wide. Where do we start? Trying it on one project is the safe move. Start with the number-check script, then expand to terminology matching once you’re comfortable. If you need to design the operation across the whole team, in training and consulting we can build the concrete flow together.

What I confirmed when I actually tried it

I ran this on a mock project on my own machine (part of a product manual, roughly 3,000 words of source). I deliberately planted bugs: I changed “Customer Account” to “User Account” in three places, and rewrote one number from “3.5” to “35.”

The number-check script caught the planted “35” in one shot as a “number only in target.” The terminology-matching prompt laid out all three style inconsistencies in a table. On the other hand, it also flagged one spot I had intentionally paraphrased for context as a “mismatch,” so there a human judged “this is an exception” and left it.

What I wanted to confirm was whether the “AI sticks the note, the human decides whether to peel it” division actually works in practice. The conclusion: just switching to a form where a human reviews machine-flagged candidates massively reduces the mental load of searching from scratch. Not perfect automation, but offloading the pre-work while preserving the human’s final judgment. For the translation-agency floor, that distance feels just right.