You can't verify a translation by reading it

You get back a piece of text in a language you do not read. A clause of a contract rendered into French, an interface string set in Korean, a report condensed into a language your reader speaks and you do not. You skim it. It looks clean: no obvious garbage, the proper nouns roughly where they should be. It looks fine, so you ship it. And "looks fine" was never a check. You just approved a transformation you have no instrument to inspect, and told yourself the glance counted as inspection.

The trap is sharper than carelessness, because a careful reading would not save you either. To confirm that a translation kept the meaning of its source, you would have to read the target language about as well as you read the original. But reading the target language that well is the capability you did not have, and it is often the reason you reached for the machine in the first place. Your eye can still catch the coarse things, a mangled number or a name that went missing. What it cannot reach is the question that matters: did the sense survive. The one property it does register, that the prose reads smoothly, is the property the model is best at producing whether or not it got the meaning right. A confident, fluent, subtly wrong translation looks exactly like a correct one, on the axis you most need to see and are least equipped to.

The general version of this is not new, and Sophie Alpert put it precisely in a writing policy that Simon Willison later surfaced and endorsed:

There are no lossless transformations of natural-language text. Every rewrite and rephrase changes the meaning of your writing, and if this is done by an entity that doesn't have the most detailed mental representation of what you personally were trying to communicate, information will be lost.

Every rewrite, not only every translation. Rephrasing in the same language has the same property; the difference is that there you can read the result and feel where it drifted from what you meant. Push the text across a language boundary and you lose even that felt signal. The transformation is still lossy, and now the loss is invisible to the one person who cares whether it happened.

If you cannot inspect the output directly, you inspect it indirectly, and the move for doing that is old. Survey researchers and clinical-instrument designers have leaned on back-translation for decades, and localization teams use it still: translate the source forward into the target language, then translate that result back into the source language with an independent pass, and set the round-trip beside the original. The comparison you now have to make happens in the one language you actually command. There is a requirement hiding in the word independent, and it is the requirement people get wrong. The back-pass must not see the source. Give it the source in the same context, or a shared conversation, or a cached exchange, and it will hand you the source back instead of translating the target, and every diff comes up clean while the check verifies nothing. Isolation is not a nicety here. It is the whole mechanism.

What you do with the diff is the part worth being precise about, because it is easy to ask it for more than it can give. Tolerate the stylistic drift, since a round-trip never returns your exact words and punishing it for that would flag everything. Attend to the substantive shifts: a negation that flipped, a figure that moved, a hedge that hardened into a promise. And notice where the judgment now lives. Whether a person reads the diff or a model triages it first, the comparison is in your language, so you can read the calls and spot-check them, which is exactly what you could never do with the target text. A model doing the triage is one more untrusted transformation, true, but an untrusted transformation whose output you can actually read is a different animal from one whose output you cannot. You reserve the bilingual human for the cases the diff flags, because reading everything twice in two languages does not pay, and the point of the gate is to spend that scarce attention where the signal says to.

Then comes the honest accounting, the part that keeps this a triage signal and not a stamp of approval. A clean round-trip does not certify the forward translation. An error that is symmetric survives it: a shared wrong mapping applied on the way out and inverted on the way back comes home looking untouched, because the second pass makes the inverse of the first pass's mistake and lands you back where you started. There is a second failure with the opposite shape, and with capable models it is the more common one. The forward pass genuinely breaks the target, and a strong back-translator, doing what it is built to do, infers what you must have meant and reconstructs clean source anyway, laundering a broken translation into a passing diff. And a dirty round-trip does not condemn the forward translation either, because the back-pass may be the one that erred. So the gate surfaces suspects. It does not clear anyone, and for a contract or anything else where a wrong word is expensive, it sits in front of bilingual review rather than replacing it.

There is one class it cannot see at all, and it is not a small one. The gate reasons about meaning, so it is blind by construction to form: formality and politeness, the level of address, the gendered forms or honorific register a language forces you to choose. A translation can be too familiar or too stiff for its reader, and round-trip to identical source, because the register never touched the propositional content the diff compares. For an interface string or a legal clause that is a shipping failure, and it is the failure a native reader notices first, while your check looks straight through it.

Turn the same principle onto text you can read, and it explains a mistake people make while trying to do better. Take a piece of product copy or documentation and run it through one cleanup pass, then another, then a third, each one asked to make it cleaner and tighter. Any editor optimizing for clean files down the irregular first: the sentence with an odd rhythm, or the one detail nobody else would have kept, or the aside that reads as a person and not a template. Those register as noise to an averaging process, so they go, and the passes do not stack toward your voice, they converge on the bland middle. Edit hard enough and the text comes out reading more like a machine, not less, sanded even and unmistakably processed. The way to sound less artificial is to stop sooner. Cap the passes. Make one coherent edit instead of compounding many small corrections that each shave off a little life, and read the result aloud once, because the ear catches the sterility that the eye keeps approving.

Both halves are the same failure. A transformation of natural language can lose something you are structurally placed not to notice: across a language boundary because you cannot read the far side, and within a language because each pass quietly erases the evidence of the last. The engineering answer is not to trust the output because it reads well. It is to move the judgment somewhere you can actually make it, back into a language you command, and into a number of passes small enough that you can still see what changed. What you cannot read, you cannot check, and reading harder was never going to be the fix.