The incident that started this story was small enough to be embarrassing. A mid-size content agency published a client thought-leadership piece in which a model-assisted proofread had quietly changed a cited research figure. The model had judged the original number odd and rewrote it to something rounder. Nobody caught it, because the corrected draft read perfectly. The client's competitor caught it instead, in a public reply, and the agency spent a week on damage control.
What follows is how that team diagnosed the problem, redesigned its error-detection prompting, rolled the new approach out across editors, and measured whether it actually worked. The arc matters more than any single prompt: this is a story about treating prompting as a process to be engineered, not a trick to be reused.
The team had been using language models for proofreading for months and assumed they were getting reliable results. The published-figure incident forced a harder look. What they found was that their entire workflow rested on a single fragile prompt, and that the fragility had been invisible only because nobody was measuring failure.
The Situation: One Prompt, No Verification
The team's standard move was to paste a draft and ask the model to "proofread and fix any errors."
What that hid
That one prompt bundled detection and correction, supplied no source of truth, set no edit budget, and was never verified. Every weakness named in Seven Ways Error-Detection Prompts Quietly Fail You was present at once. The output looked finished, so it skipped review.
The trigger
The altered research figure was the first failure visible enough to force a change. The team realized they had no idea how many smaller errors had already shipped undetected.
The Decision: Treat Detection and Correction as Separate Stages
The editorial lead made one structural call: detection and correction would never again happen in a single prompt.
Why this call
Separating the phases would create an audit trail. Editors could see what the model flagged and why before any text changed, which meant a flawed correction could be caught at the reasoning stage rather than after publication. This staged model is described in The DETECT Loop: A Reusable Model for Catching AI Errors.
The supporting rule
Every detection prompt would require a source of truth: the brief, the cited sources, or the client style guide, pasted inline. The model was forbidden from using outside knowledge to "correct" facts.
The Execution: A Three-Pass Workflow
The team built a standard three-pass workflow and trained every editor on it.
The three passes
- Detection: "Using only the attached sources, list every factual or logical error with its location and reason. Do not edit."
- Correction: "Propose the minimal change to fix each flagged error. Preserve all other wording."
- Verification: "Confirm each flagged error is resolved and identify any new error introduced."
The rollout
They piloted on one client account for two weeks, refined the prompt wording against a set of drafts with known planted errors, then expanded to the full team. The calibration step came straight from Hard-Won Rules for Error-Checking Prompts That Hold Up.
The Outcome: Measurable and Defensible
The team instrumented the workflow so they could prove it worked rather than assume it.
What they measured
They tracked the rate of errors caught on the planted-error test set, the false-positive rate, and the number of client-reported errors per quarter. False positives dropped sharply once the error taxonomy was scoped, and client-reported errors fell to near zero over the following two quarters.
The unexpected benefit
The audit trail became a client deliverable. When a client questioned an edit, the team could show the flagged reason and the supplied source, turning a defensive conversation into a credibility-building one. The metrics they chose are covered in The Numbers That Tell You an Error-Detection Prompt Works.
The Lessons That Generalized
Stripped of the specifics, the team's takeaways transfer to any error-detection workflow.
What they would tell another team
Never run detection and correction in one prompt for anything that ships. Always supply the source of truth inline. Calibrate on known-bad examples before trusting a prompt. And measure failure, because a workflow you do not measure is one whose failures you simply have not noticed yet.
The Obstacles Along the Way
The rollout was not frictionless, and the obstacles are as instructive as the wins.
What resisted
Editors initially saw the three passes as bureaucracy that slowed them down. Adoption stalled until the lead reframed the passes as protection rather than process, showing the team the planted-error drafts the old single prompt had missed. Once editors saw the misses with their own eyes, resistance evaporated.
The calibration surprise
The team assumed their first prompt wording was fine and discovered, against the known-bad set, that it missed an entire category of error: contradictions between two distant sections. No amount of single-document prompting caught these; only a dedicated cross-section consistency pass did. That discovery reshaped the workflow and mirrors the chunking lesson in Five Error-Detection Prompts, Walked Through End to End.
What Changed in Day-to-Day Work
Beyond the metrics, the workflow changed how editors actually worked.
The new rhythm
Editors stopped treating the model's output as a finished draft to skim and started treating it as a flagged list to adjudicate. The cognitive shift mattered: they were now reviewing reasoning, not prose, which is faster and more reliable. The smallest-viable-change rule meant diffs were short and easy to scan rather than full rewrites to re-read.
The cultural effect
Measuring failure changed the team's relationship to mistakes. Instead of an escaped error being a source of blame, it became a new entry in the known-bad set and a chance to improve the prompt. That shift, from hiding failures to harvesting them, is the deeper lesson behind the metrics in The Numbers That Tell You an Error-Detection Prompt Works.
Frequently Asked Questions
What was the root cause of the original published error?
A single prompt that bundled detection and correction with no source of truth and no verification. The model altered a real figure it found unusual, and because the rewrite read cleanly, the change bypassed review entirely.
Why separate detection from correction if it adds a step?
Separation creates an audit trail. Editors review the model's reasoning before any text changes, so a bad correction is caught at the reasoning stage rather than after publication. The extra step replaces an expensive failure with a cheap one.
How long did the rollout take?
A two-week pilot on one account, prompt calibration against drafts with planted errors, then expansion to the full team. The calibration step was essential; it proved the prompts caught known errors before they were trusted on live work.
What was the most surprising result?
That the audit trail became a client-facing asset. Being able to show why an edit was made, with the supplied source, turned questions about edits into demonstrations of rigor.
How did the team know the new workflow actually worked?
They measured. Catch rate on a planted-error set, false-positive rate, and client-reported errors per quarter all moved in the right direction, giving them evidence rather than a hunch.
Could a smaller team adopt this without the same overhead?
Yes. The three passes can run in minutes for a single piece. The overhead is mostly one-time: building a small known-bad test set and writing the standard prompts. After that the per-document cost is low.
Sustaining the Workflow After the Initial Win
The harder challenge came after the metrics improved: keeping the discipline alive.
Where the risk of regression lived
A few months in, with client-reported errors near zero, the temptation to shortcut the passes returned. Editors under deadline pressure started collapsing detection and correction again on smaller pieces. The lead countered this by tying the workflow to the metrics, showing that the months without escapes coincided exactly with consistent use of the three passes, and that the one escape in that period traced to a shortcut.
The habit that held
What ultimately sustained the workflow was making the audit trail a required deliverable rather than an optional artifact. Because every piece had to ship with its flagged-error record, skipping the detection pass was no longer possible without leaving an obvious gap. The process became self-enforcing, mirroring the gating discipline in A Working Pre-Flight List for Error-Detection Prompts in 2026.
Key Takeaways
- A single bundled prompt with no verification is how a real, costly error reached publication.
- Separating detection from correction created the audit trail that prevented repeat failures.
- Supplying the source of truth inline stopped the model from altering accurate facts.
- Calibrating prompts on planted errors proved reliability before live use.
- Measuring catch rate, false positives, and client-reported errors made the win defensible.
- The audit trail became a client deliverable, turning rigor into a credibility asset.