The file landed in your queue at 9:14 on a Tuesday, and it looked like a gift. Two hundred segments of a medical-device user manual, German into English, every single segment already pre-translated by the engine before you opened the project. The translation-management system had done what it always does now: it auto-populated the target column from the machine-translation engine the moment the job was created, so you are not staring at an empty grid the way you were five years ago. You are staring at a grid that is already full, already fluent, already reading like a careful technical writer produced it. And that is the trap, dressed up as a head start. Somewhere in those two hundred smooth, grammatical, native-sounding segments are three or four that mean the opposite of the German, and your eye, trained over a career to trust prose that flows, will glide across every one of them at reading speed and your name will be on the delivery. This lesson is about the single habit that catches those segments. Not a better eye, not more caffeine, not more years of experience. A different operation entirely: cross-checking every claim against the source segment, never against the smooth target. We are going to build that habit slowly, name exactly what to check first, and then walk through a real pretranslated file and catch the fluent-but-wrong segments one at a time, the way you will do it on Monday.

The Habit That Replaces the Reflex

Before we touch a single segment, you need to understand why your instinct is the problem, because the habit we are building exists specifically to defeat your instinct. When you read a sentence in your native language and it flows, your brain does not laboriously verify every word. It predicts ahead. It samples the first few words, guesses the shape of the rest, skims the surface to confirm the guess, and moves on. This is what fluent reading is, and it is a magnificent piece of engineering when you are reading a novel. It is a catastrophe when you are post-editing machine output, because the machine produces fluency for free and accuracy only by accident, and your fluent-reading brain is calibrated to wave the fluent sentence through.

Let us fix the vocabulary first, because we will use it precisely for the rest of the lesson. Machine translation (MT) is any system that converts text from a source language to a target language with no human writing the words. Neural machine translation (NMT) is the production-grade flavor that has dominated since around 2016, a neural network trained only on the translation task. A large language model (LLM) is a general-purpose text-prediction system that translates as a side effect of its broad competence and tends to be even more fluent, and more confidently wrong, than classic NMT. Machine-translation post-editing (MTPE), often shortened to PE, is the workflow you are in: a human editing machine output instead of translating from a blank target. A segment is the unit you work in, usually a sentence or a sentence-like chunk, the row in your grid with a source cell and a target cell. The source segment is the original-language cell; the target segment is the machine's rendering of it. A termbase is the client's controlled glossary of approved terms. A computer-assisted translation (CAT) tool is the editing environment with the two-column grid; the translation-management system (TMS) is the platform that routes the job, applies the MT, and stores the delivery. And a pretranslated file, the thing in your queue, is a file whose target cells were already filled by the engine before you arrived.

Now the habit itself, stated as plainly as it can be stated, because everything else in this lesson is an elaboration of this one sentence:

Do not check whether the target reads well. Check whether the target says what the source says. The first is an impression of one cell; the second is a comparison of two, and only the comparison can catch the fluent mistranslation.

Read that twice. The difference between a post-editor whose role moves up in the MT era and one who becomes its casualty is contained in it. Checking whether the target reads well is an operation you perform on the target alone. You can do it without ever glancing at the source, which is exactly why it feels fast and exactly why it is worthless against a fluent error. The fluent error also reads well; that is its entire nature. To check whether the target says what the source says, you are forced to look at both cells, to put your finger on the source claim and your finger on the target claim and ask whether they match. Fluency lives in only one of those two cells. A comparison between them cannot be seduced by it. That is the whole trick, and it is why we call it reading against the source rather than reading the target.

Why "Read More Carefully" Is Not the Answer

People who have not lived inside an MTPE file imagine the solution is vigilance: read slower, read twice, concentrate harder. This is well-meant and it does not work, and understanding why it does not work is what justifies the entire discipline. Vigilance applied to reading the target for flow just makes you better at the operation that was never going to catch the error. You can read a fluent contraindication that has had its negation dropped a hundred times with maximum concentration, and a hundred times your predictive reading brain will confirm that yes, this is a smooth, grammatical, professional English sentence, because it is. Concentration does not change the operation; it just intensifies the wrong one. The negation is not missing from the grammar. It is missing from the meaning, and meaning is only visible when you hold the target up against the source. You cannot concentrate your way out of comparing the wrong thing. You have to compare the right thing, which is the source claim against the target claim, deliberately, on the elements where a flip is catastrophic. That deliberate comparison is the habit. The rest of the lesson teaches you where to point it and shows you it working.

What to Check First: The High-Consequence Six

You cannot read every segment against the source with equal slow intensity; a two-hundred-segment file would take a week and the budget assumes a day. The discipline is not infinite suspicion. It is targeted suspicion: a specific, memorized list of element types where a fluent engine fails hardest and where a flip is most catastrophic, checked against the source on every segment that contains them, with the smoother surrounding prose getting the faster pass. The reason these specific categories are the trap is worth one sentence of theory before the list: an MT or LLM engine optimizes for probable, fluent target text, and the elements that carry the most meaning in high-stakes content often carry the least statistical weight, so the engine smooths right over them without disturbing the grammar. A negation is a tiny word. A digit is one character. A drug name competes against more common near-neighbors. The catastrophic content and the statistically negligible content are frequently the same tokens, and the engine flattens them into a sentence that reads beautifully. So you check, first and always, these six.

Negations and Polarity

A negation is the highest-value, lowest-effort target in the entire file, because flipping it costs the engine one dropped word and costs the reader everything. Find every "not," every "no," every "never," every prohibition, every "must not," "do not," "shall not," "contraindicated," "is not indicated," and confirm that its polarity survived into the target. The German "darf nicht" (must not) becoming an English "may" is a one-word evaporation that turns a prohibition into a permission, and the resulting English sentence is flawless. Negations also hide inside single morphemes and prefixes, in "un-", "in-", "non-", and in verbs that carry the negation lexically, "fails to," "lacks," "excludes," so polarity is about the meaning of the claim, not just the presence of the word "not." On any segment that prohibits, contraindicates, excludes, or warns against something, your first move is to confirm the prohibition is still a prohibition in the target. A dropped or added negation is the single most common silent Critical error in regulated content, and it is the easiest to catch the instant you are comparing rather than reading.

Numbers, Dosages, and Units

Check every figure character by character against the source. 2.5 is not 25; a decimal point an engine drops or moves changes a dose by a factor of ten. A comma and a period swap their meaning across locales, so the German "1.000" (one thousand) and "1,5" (one and a half) are landmines when rendered into an English convention that reads them the other way. Units are part of the number: mg is not mcg, mL is not L, "twice daily" is not "twice weekly," "every 4 hours" is not "every 4 days." The fluent prose wrapped around a wrong number does nothing to protect the number, and your reading brain will accept "take 25 milligrams" as serenely as "take 2.5 milligrams," because both are grammatical English sentences. Numbers do not get read; they get verified, digit by digit, separator by separator, unit by unit, against the source.

Named Entities and Approved Terms

A named entity is a drug name, a product name, a company name, a person, a place, a device model. Confirm the exact entity survived, and confirm it survived as the client's approved term from the termbase, not as a fluent synonym the engine preferred. An engine that has seen a more common drug name far more often in training will sometimes substitute it for a rarer one, producing a perfect sentence about the wrong medicine. An engine that does not know the client mandated "the Device" with a capital D and a specific model number will cheerfully call it "the unit" or "the apparatus" and read beautifully doing it. Named entities are identity-critical; a substituted one is a Critical error that reads perfectly and that no amount of fluency-checking will surface, because the substitute is just as fluent as the correct term.

Obligations and Parties

In any content with legal, contractual, or procedural force, confirm who must do what to whom. Legal and regulatory language is built from a few enormously weighted words, "shall" and "shall not," "must," "may," "indemnify," "be liable," "warrant," "is responsible for," and from the direction of the obligation between parties. A fluent engine that swaps which party indemnifies which, or that renders "the supplier shall not be liable" as "the supplier shall be liable," has produced a clean, lawyerly clause that allocates the risk to the wrong party. Both versions read with identical professional authority. On any segment that imposes an obligation, assigns liability, grants permission, or names who does what, your check is not "does this read like a contract"; it is "is the obligation pointing the same direction as the source, between the same parties."

Dates, Times, and Scope Words

Verify dates, times, and durations against the source and against the locale convention, because an ambiguous or flipped date in a dosing schedule, a deadline, or an effective date is high-consequence and because date formats themselves invert across locales (the same digits can read as day-month or month-day). Alongside dates, watch the small scope and quantity words that change the size of a claim without disturbing its grammar: "only," "at least," "no more than," "up to," "including," "excluding," "except," "all," "any," "each." These words are tiny, they are easy for an engine to drop or swap, and each one resizes the claim. "At least 5" is not "no more than 5." "Including" is not "including without limitation." A dropped "only" widens a restriction into a generality. Scope words travel with negations on the high-alert list because both are low-statistical-weight, high-meaning tokens.

Adverse Events, Warnings, and Conditions

Confirm that any description of harm, any safety warning, any conditional ("if X, then do not Y"), and any line between expected and dangerous matches the source exactly. This is where medical and life-safety content concentrates its risk: the sentence that tells a patient which symptom is a normal side effect to wait out and which is a stroke to rush to the hospital for, the sentence that tells an operator when the machine is safe and when it will take a hand off. Conditionals are especially fragile because they have two halves and a logical connector, and an engine can preserve the words while scrambling the logic, attaching the action to the wrong condition. Read the whole conditional against the source as a unit: same trigger, same action, same direction.

Negations, numbers, named entities, obligations, dates and scope words, and warnings. Memorize the six. They are where the engine's fluency and its inaccuracy overlap, and they are what you check against the source before you trust a single smooth segment.

The Mechanics of Reading Against the Source

Knowing what to check is half the habit. The other half is the physical, procedural method of doing it inside a real CAT grid under a real deadline, because a discipline you cannot actually perform at working speed is a lecture, not a habit. Here is the mechanics, built to be fast enough to survive a two-hundred-segment day and rigorous enough to catch the flip.

Read the Source First, Then the Target

The order matters more than it seems. If you read the fluent target first, it plants an expectation in your mind, and when you then glance at the source you tend to confirm the expectation rather than test it. Your brain has already decided what the sentence means, and it goes looking for agreement. Reverse the order. Read the source segment first and form your own understanding of what it claims, independently, before the machine's fluent version has a chance to anchor you. Then turn to the target and ask whether it carries your understanding of the source, not whether it reads well. This single reordering, source before target, is one of the highest-leverage changes you can make, because it stops the fluent target from doing your thinking for you. On the segments that contain one of the high-consequence six, slow down here deliberately and verify that specific element across the two cells before moving on.

Point and Match, Element by Element

On a high-consequence segment, do not read the two cells as wholes and compare gestalt impressions. Decompose. Put your attention on the source negation and find its match in the target: present, same polarity, attached to the same verb. Put your attention on the source number and find its match: same digits, same separator, same unit. Put your attention on the source obligation and find its match: same party, same direction. You are matching elements, not absorbing sentences. This is slower than reading and it is supposed to be, and it is only applied to the elements that matter, so the cost is bounded. The clean connective prose between the high-consequence elements gets a faster pass; the negation, the dosage, the indemnity, the conditional get the point-and-match treatment. You are spending your limited slow attention precisely where a flip is catastrophic and nowhere else.

Treat Suspicious Fluency as a Warning, Not a Reassurance

Here is the inversion of instinct that takes the longest to internalize and pays the most. A segment that is perfectly smooth, confident, and natural is not thereby trustworthy. It is, if anything, the segment to slow down on, because the fluent error is camouflaged in exactly that smoothness. This does not mean every fluent segment is wrong, which would be paralyzing. It means fluency is not evidence of correctness and must never be allowed to stand in for the source check. When you notice yourself thinking "this one reads great, I can skip the comparison," that thought is the precise moment the trap is closing, and it is the cue to do the comparison anyway on any high-consequence element the segment contains. The engine's confidence is uniform: it writes the segment it has right and the segment it has hallucinated in the same steady voice, so the smoothness of the prose carries zero information about which segments to doubt. The doubt has to come from you, applied by rule to the high-consequence six, regardless of how good the prose looks.

Flag, Then Fix, So You Never Lose the Find

One operational note that saves shipped Criticals. When you catch a fluent-but-wrong segment, your impulse is to fix it immediately and move on. Resist long enough to flag it, mark it, comment it, or log it, so that the catch is recorded, because the same against-the-source pass that found it is the artifact that proves you did the verification, and because a half-fixed segment you got distracted away from is a segment that ships wrong. The flag also feeds the quality record the client and the standard expect: under the revised post-editing standard, the human is accountable for the delivery, and a log of what you checked and caught is how that accountability is demonstrated rather than merely asserted. Catch, flag, then fix.

The Walkthrough: Catching Them in a Pretranslated File

Now we do it for real. Below is a walkthrough of the kind of file that opened this lesson: a German-to-English medical-device manual, pretranslated by the engine, every target cell already full and already fluent. We will move through a handful of segments exactly the way you would in the grid: read the source first, form the claim, then point-and-match the high-consequence elements against the target. Some segments are clean. Some are fluent and wrong. The whole point is that you cannot tell which from the target alone, which is why we never look at the target alone.

Segment 1: The Dropped Negation

Source (DE): "Das Gerät darf nicht in der Nähe von brennbaren Anästhesiegemischen verwendet werden."

Target (EN), as pretranslated: "The device may be used near flammable anesthetic mixtures."

Read the source first. The claim is a prohibition: the device must not be used near flammable anesthetic mixtures. "Darf nicht" is the negated obligation, the polarity-bearing core of the sentence. Now point-and-match. Where is the negation in the target? It is gone. "Darf nicht" (must not) has become "may," and "may" is not a weakened prohibition; it is an explicit permission. The English is grammatical, natural, and reads like a competent technical writer wrote it. It is also a Critical error: it instructs an operator to do the one thing the source forbids, near flammable gas, in a setting where the consequence is fire in an operating room. Notice what caught it. Not the flow, which was perfect. The polarity check on segment that prohibits something: the first item on the high-consequence six. Read for flow, this segment is flawless. Read against the source, the missing negation is the first thing you find. Flag it as a Critical, then fix the target to "The device must not be used near flammable anesthetic mixtures."

Segment 2: The Moved Decimal and the Locale Separator

Source (DE): "Stellen Sie den Durchfluss auf 2,5 ml pro Minute ein."

Target (EN), as pretranslated: "Set the flow rate to 25 mL per minute."

Read the source: set the flow rate to two-and-a-half milliliters per minute. The German decimal comma in "2,5" means two point five. Point-and-match the number. The target says "25." The decimal comma was read as a thousands separator or simply dropped, and 2.5 became 25, a tenfold error in a flow rate that governs how fast something enters a patient. The unit, mL, is correct, which is exactly the kind of partial correctness that makes the segment feel trustworthy. The sentence is a perfect English imperative. It is also off by a factor of ten on a clinical dosing parameter. This is why numbers are verified character by character and separator by separator rather than read: the locale convention for the decimal mark inverts between German and English, and the engine flattened it into a fluent sentence with the wrong magnitude. Flag as Critical, fix to "2.5 mL per minute."

Segment 3: The Fluent Synonym That Broke the Termbase

Source (DE): "Reinigen Sie die Messsonde vor jeder Anwendung."

Target (EN), as pretranslated: "Clean the probe before each use."

This one is subtler, and it is the kind that separates a post-editor who checks against the source and the termbase from one who only checks for sense. Read the source: clean the "Messsonde" before each use. The sentence is about a specific component. Now the termbase check: the client's approved English term for "Messsonde" is "measuring sensor," not "probe." "Probe" is a perfectly fluent, perfectly reasonable English rendering. It is also wrong, because in this device's documentation "probe" refers to a different physical part, and using it here creates a cross-reference error that sends the user to clean the wrong component. The meaning is not catastrophically inverted the way the negation was, so this is not automatically a Critical; depending on the consequence of cleaning the wrong part, it is a Major terminology error at minimum. The lesson it teaches is that "reads correctly" is not enough: the named-entity-and-approved-term check on the high-consequence six is specifically about the client's controlled term, and a fluent synonym fails it. Flag as a terminology error, fix to the approved "measuring sensor."

Segment 4: The Clean One (and Why You Still Checked)

Source (DE): "Schalten Sie das Gerät aus und ziehen Sie den Netzstecker."

Target (EN), as pretranslated: "Switch off the device and unplug the power cord."

Read the source: switch off the device and pull the mains plug. Point-and-match. There is no negation to flip, the obligation is a simple instruction in the same direction, there are no numbers, the entities ("device," "power cord") match and are consistent with the termbase, and the two clauses are in the right order. This segment is correct, and you confirmed it correct by the same against-the-source operation, not by trusting its fluency. This matters for two reasons. First, it shows the discipline is not paranoia that rejects everything; most segments are fine, and the method confirms the fine ones quickly because they have no high-consequence elements to slow down on. Second, it shows that the clean segment and the inverted contraindication in Segment 1 are indistinguishable from the target alone: both are smooth, both are grammatical, both read like a professional wrote them. The only thing that told them apart was the comparison to the source. That is the entire argument of the lesson, demonstrated in two segments that look equally trustworthy and are not.

Segment 5: The Conditional With the Right Words and the Wrong Logic

Source (DE): "Wenn die Kontrollleuchte rot blinkt, verwenden Sie das Gerät nicht und kontaktieren Sie den Kundendienst."

Target (EN), as pretranslated: "If the indicator light flashes red, use the device and contact customer service."

Read the source carefully as a unit, because it is a conditional with two halves: if the indicator light flashes red, then do not use the device and contact customer service. The trigger is "red flashing light," and the instructed action has two parts, a prohibition ("verwenden Sie das Gerät nicht," do not use the device) and a direction ("contact customer service"). Now point-and-match the whole conditional. The trigger survived. "Contact customer service" survived. But the prohibition, "nicht," evaporated: the target says "use the device" where the source says "do not use the device." This is the negation failure mode again, this time hiding inside a conditional where the surrounding correct material, the right trigger and the right second instruction, makes the segment feel even more trustworthy than a bare flipped sentence would. A user whose device flashes a red fault light is told to keep using it. This is a Critical safety error wearing the costume of a correctly-translated instruction. Caught only because the conditional was read against the source as a unit and the negation inside the action half was checked for polarity. Flag Critical, fix to "do not use the device."

What the Walkthrough Proves

Five segments, three of them fluent and wrong in ways the eye skips, and every catch came from the same operation: read the source first, form the claim yourself, then point-and-match the high-consequence elements against the target without letting the smooth surface vote. The dropped negation in Segment 1, the moved decimal in Segment 2, and the inverted conditional in Segment 5 are all Critical or near-Critical, all delivered in flawless English, and all invisible to a flow read. The termbase miss in Segment 3 is the quieter terminology failure that only the approved-term check surfaces. And Segment 4, the clean one, proves the negative case: from the target alone it is identical in trustworthiness to Segment 1, and only the source comparison told them apart. If you carry one image out of this lesson, carry the grid: two columns, your finger on the source claim and your finger on the target claim, asking not "is this good English" but "is this the same claim," six times per high-consequence segment, two hundred segments deep, and the fluent mistranslation that would have shipped does not.

Why This Discipline Is the Whole Job Now

It is worth stepping back to see why this one habit carries so much weight, because it reframes what your value is in a pipeline where the engine already filled every cell. When the target column arrives empty, your value is obvious: you produce the translation. When the target column arrives full and fluent, the naive view is that your value has shrunk to light cleanup, and that is precisely the view that collapses per-word rates and turns the post-editor into the machine's underpaid janitor. The against-the-source discipline is the answer to that view. The engine handed you fluency, which it produces for free and guarantees on every segment. It did not, and structurally cannot, hand you accuracy, which is a relationship between the target and the source meaning and the approved terms that the engine never verifies. The single thing the machine cannot supply is the exact thing you supply by reading against the source: the verified relationship between the fluent output and what the source actually said. That verification is not cleanup. It is the entire reason a human is in the loop, and on high-consequence content it is the most valuable thing in the workflow.

This is also why the accountability sits with you and not the engine, and why "the machine wrote it" is never an answer when a Critical ships. The revised ISO 18587, the post-editing standard expanded to cover AI and LLM "non-human translation output" and in DIS ballot with publication targeted for late 2025 into 2026, makes this explicit by requiring the post-editor to hold the same full linguistic competence as a professional translator, precisely because catching the fluent error in high-stakes content is a translator's judgment exercised against the source, not a button-pusher's reflex exercised against the surface. When you internalize the against-the-source habit, you are not just catching errors. You are occupying the role the standard reserves for a full-competence linguist and that a raw MT vendor cannot fill: the human who can stand behind the delivery because they checked the claims, not the flow.

The Effort Is Matched to the Consequence

One guardrail so the discipline does not curdle into over-editing. Reading against the source on the high-consequence six is the non-negotiable core, but the depth you apply scales with what the content can do to someone. On a regulated medical or legal or financial file, every negation, number, named entity, obligation, date, and warning gets the full point-and-match treatment, because a flip there is a recall or a lawsuit. On a low-stakes marketing string or an internal knowledge-base article, a fluent error is recoverable, the source check on the six is lighter and faster, and you are not obligated to verify every digit as if a life depended on it, because none does. The habit is universal; the intensity is proportional. What never scales away, on any content, is the principle that the check runs against the source and never against the smooth target, because that is the only operation a fluent error cannot survive. Spending your slow, against-the-source attention exactly where a flip is catastrophic, and reading faster where it is not, is what lets you finish the two-hundred-segment file by the deadline while still catching the three segments that would have ended a relationship.

Key Takeaways

• The single habit that catches the fluent mistranslation is to cross-check every claim against the source segment, never against the smooth target. Checking whether the target reads well is an impression of one cell; checking whether it says what the source says is a comparison of two cells, and only the comparison can catch an error that is itself perfectly fluent.
• Vigilance is not the fix. Reading the target more carefully for flow just intensifies the operation that was never going to catch the error, because the dropped negation is missing from the meaning, not the grammar, and meaning is only visible when the target is held against the source.
• Check the high-consequence six on every segment that contains them: negations and polarity, numbers and dosages and units, named entities and approved terms, obligations and parties, dates and scope words, and adverse events and warnings. These are where an engine's fluency and its inaccuracy overlap, because the most meaning-critical tokens often carry the least statistical weight and get smoothed into grammatical sentences.
• The mechanics: read the source segment first and form the claim yourself before the fluent target anchors you, then point-and-match the high-consequence elements element by element rather than comparing whole-sentence impressions. Treat suspicious fluency as a cue to slow down, not as reassurance, and flag the catch before you fix it so the verification is recorded.
• In the worked walkthrough, three of five fluent German-to-English segments were wrong: a dropped negation that turned a prohibition into a permission near flammable gas, a moved decimal that turned 2.5 mL into 25 mL, and an inverted conditional that told a user to keep operating a device showing a red fault light, plus a fluent synonym that broke the client's approved term. Every catch came from reading against the source, never from reading the target.
• The clean segment proved the core argument: from the target alone, a correct instruction and an inverted contraindication are indistinguishable, both smooth and grammatical, and only the source comparison tells them apart. Fluency carries zero information about which segments to doubt, so the doubt must come from you, applied by rule.
• This discipline is your value in an MT-first pipeline, not cleanup. The engine guarantees fluency for free and structurally cannot verify accuracy, which is a relationship to the source meaning and the approved terms; supplying that verified relationship is the entire reason a human is in the loop, and accountability for a shipped Critical sits with the human, not the engine.
• The habit is universal but its intensity is proportional to consequence: full point-and-match on every high-consequence element in regulated medical, legal, and financial content, a lighter and faster source check on low-stakes content. What never scales away is that the check runs against the source and never against the smooth target, the one operation a fluent error cannot survive, in the spirit of the revised ISO 18587 that holds the post-editor to full professional-translator competence.