Imagine a photocopier that, every time you feed it a document, quietly changes a number, drops a clause, or reassigns a quote to the wrong author. That is exactly what LLMs do when you delegate content editing to them in a loop: they don't crash, they don't throw errors, they just corrupt. And they do it so smoothly that no one notices until the damage is already live.
TL;DR: No Fluff, Just Facts
- DELEGATE-52: Microsoft evaluated 19 LLMs across 52 domains. The best models corrupted 25% of content after 20 editing iterations.
- Invisible errors: not typos. Altered figures, false attributions, and vanishing clauses that standard review routinely misses.
- Production pressure: AI referrals grew 197% year-over-year (Shopify) while teams are producing more with less human oversight.
- After iteration 10: the risk of serious corruption spikes sharply. Two-round demos tell you absolutely nothing.
What Is DELEGATE-52 and Why Should You Care?
DELEGATE-52 is a Microsoft Research study published in April 2026. It evaluated 19 language models across 52 professional domains, simulating a delegated editing process over 20 iterations.
The result: frontier models corrupted an average of 25% of document content. The overall average across all models tested hit 50%. Forget typos. We are talking about figures that mutate without warning and authorship that suddenly belongs to someone else.
The worst part: these errors are subtle enough that a human in a hurry, which is everyone working in this industry, will wave them right through. They accumulate in silence, iteration after iteration.
Watch out for agentic tools: they did not improve things. In fact, they made performance worse in 6% of cases. The only domain where LLMs maintained accuracy was Python, with over 98% fidelity. Everything else: silent corruption.
When Does the Real Risk Kick In?
In the first two rounds, you won't notice a thing. Almost every model evaluated showed similar performance and negligible errors at round two. Run a short test and you walk away impressed.
That is precisely the trap.
DELEGATE-52 showed that models that looked virtually identical at iteration 2 diverged sharply by iteration 10. Beyond 10 to 15 editing rounds, the probability of serious corruption spikes. By iteration 20, a quarter of the content is compromised, with the best models on the market.
Translated to your day-to-day: if your production workflow runs a piece of text through an LLM more than a couple of times, draft, revision, SEO optimization, channel adaptation, you are already stacking risk. Most teams I know run considerably more passes than that.
My best guess for why Python escapes is straightforward: it has a verifiable ground truth. The test passes or it fails. There is no middle ground.
Marketing prose has no such mechanism. A paragraph with one altered figure still reads perfectly fine. And a convincing text with a false data point buried inside it is the worst-case scenario for your brand.
The polish is the camouflage.
Which Workflows Are Most Exposed?
Any process involving multiple rounds of LLM-delegated editing is a candidate. But a few stand out as high-alert:
- Blogs with a draft-revision-SEO-publish cycle: if each step goes through the model, that is four-plus iterations right there.
- Email campaigns with variants and personalization: every variant is one more iteration.
- E-commerce product descriptions at scale: hundreds of listings generated and "polished" by AI.
- Client-facing reports with data: here, a changed number is not an editorial slip, it is a trust problem.
And all of this against a backdrop of relentless pressure. According to Shopify data, AI-driven referrals grew 197% year-over-year in Q2 2026. More channels, more content, fewer people to review it. The incentive to delegate and skip the check is enormous.
As I cover in the AI content automation guide, scaling production with language models makes complete sense. But scaling without controls is sowing errors at industrial speed. And at industrial speed, 25% corruption is a reputational crisis on a timer. Just a matter of when.
QA Controls You Should Have Built Yesterday
If you are already using LLMs in production, and you probably are, keep going. Just stop trusting them blindly.
A solid editorial workflow with human review needs guardrails the model itself cannot put in place. In my experience, these are what stop scaling output from meaning scaling mistakes:
- Human sign-off on every high-stakes decision: an LLM is not the final authority on any document that carries your brand.
- Verify data against the original source: figures and attributions get checked against the source document, NEVER against the previous version, which may already be corrupted.
- Compare versions against the original: not against the last iteration. Corruption is cumulative; if you only look at the most recent change, you miss the drift entirely.
- Cap the number of delegated iterations: three LLM passes, then a full human review before continuing. Not a magic number, but DELEGATE-52 makes it clear that every round adds risk.
- AI-specific error checklist: standard editorial review is not enough. You need a dedicated step for hunting invented figures and attributions that don't match the original source.
And do not trust demos. If you are going to integrate an LLM into your production workflow, demand evidence from at least 20 iterations. A two-round demo tells you absolutely nothing.
The "AI that edits itself" narrative has a gap the size of DELEGATE-52: it works until it doesn't, and when it fails it won't warn you. Delegating editing to a model without human review is negligence on autopilot. Plain and simple.
