Generative tools have lowered the cost of producing words to almost nothing. They have not lowered the cost of being wrong in public, and for anyone who publishes information to the public that gap is the whole problem.
Last month a member of the New Brunswick legislature read out, word for word, in the chamber, on the record: “Here’s a more natural, flowing version of that section that reads like a legislative speech rather than a series of short points.” That was not his speech. That was the chatbot’s note to him about his speech. He read the instruction and the content as if they were the same thing.
It is a funny clip. It is also a small, visible withdrawal from a public account that took a long time to fill. The words were free to generate. The damage to trust was not.
The cost has moved, not disappeared
For most of the history of public communication, producing the words was the expensive part. Drafting, checking, clearing and publishing all took effort, and that effort acted as a brake. You could not publish much rubbish quickly because you could not publish much of anything quickly.
Generative tools have removed that brake. The cost of the first draft is now close to zero. What has not changed is the cost of being wrong once it reaches the public. If anything that cost has gone up, because the same tool that writes one page writes ten thousand, and an error in the template is an error in every copy. The words got cheap. The consequences did not. The two used to rise together, and now they have come apart.
Trust is what the mistake spends
I have spent years working on the delivery side of public-sector product, including publishing information to the public. The thing you learn quickly is that the content is downstream of the trust. People act on a benefits page, a health message or a set of official statistics because they believe it has been checked. Take that belief away and the same words stop working.
That is why being wrong in public is expensive in a way being wrong in private is not. A public mistake does not just cost the correction. It costs a little of the reason people believed the last thing you published, and the next reader remembers it. Cheap words, spent against an account that is slow to refill. That is the trade every organisation publishing with generative tools is now making, whether or not it has noticed.
The obvious lesson is the wrong one
The reflex response to the Oliver clip is “keep a human in the loop.” I think that lesson is wrong, or at least badly incomplete.
He was the human in the loop. He was the last person to see the text before it went public. The loop did not fail because a human was missing. It failed because the human was not checking. A person who signs off without reading is not a control. They are a rubber stamp with a pulse.
The UK government has already written the better version of the rule down. The Generative AI Framework for HMG asks for “meaningful human control” over these systems. The word that does the work is “meaningful.” Oliver had human control. It was not meaningful. Sign-off that does not actually check is the thing the framework is warning against, and it is the thing that quietly spends public trust while looking like governance.
What a gate actually is
You do not push code to production because it looked right on a laptop. You test it in an environment that mirrors production. You load-test to find the breaking point before your users find it for you. I have been on the bridge call in the small hours when something got through that should not have. The lesson from every one of those nights is the same. The gate is not optional, and the gate is not the same thing as the person who wrote the work.
Published content deserves the same treatment. A statistics release is a release. A guidance update is a release. A generated reply to a member of the public is a release. Each one is a moment where being wrong is expensive. The Oliver clip is embarrassing because the release happened to be a human reading aloud. Most of the public-facing content coming down the line will not have a human reading aloud. It will go out on its own, at the low cost the tools now make possible.
Checking output stopped being a hope and became a design decision
Here is the part worth paying attention to. Verifying generated content used to mean “someone eyeballs it.” That does not scale to the volume these tools produce, and as Oliver proved, it does not even reliably work at volume one. That has changed in the last year. Checking generated output is now something you can build into the pipeline.
The pattern that has settled in 2026 is called LLM-as-judge. You use a second model to score the first model’s output against a rubric before that output is allowed through. The interesting part is where the check sits. Teams place these checks at specific boundaries: before anything reaches a user, before any irreversible action, and before anything is written to a store the system will later trust. Some of it runs on small, cheap models at sub-second speed, with the expensive model kept for the highest-risk cases. There are now dedicated verification agents whose only job is to check another system’s work for completeness and correctness, and evaluation scores that act as live gates on what a system is allowed to publish, rather than reports someone reads after the event.
You do not have to adopt any specific tool to take the point. Checking has become cheap enough to keep pace with producing. For the first time the cost of verifying can rise alongside the cost of generating, instead of falling behind it.
Who checks the checker
The obvious objection is that an LLM-as-judge is itself generated output. I am proposing that you check AI with more AI. That deserves a straight answer. The judge does not make the failure rate zero. It is another model and it can be wrong. What it does is lower the failure rate at the boundary that matters, at a speed and cost no human can match across thousands of published items. It does not replace meaningful human control at the points of highest consequence. It extends a real check to the vast middle where the only honest alternative, at volume, is no check at all. Not a perfect human against a flawed machine, but a flawed machine against nothing.
Speed is not the value at stake
The usual challenge to all of this is speed. Generative tools are prized for throughput, and every check you add is friction. In a commercial setting that trade-off is real. In public publishing it is weaker than it looks, because the thing you are protecting is not speed. It is the trust that makes the words worth publishing at all. A fast wrong answer on an official channel costs more than a slow right one, and it keeps costing after the correction goes out.
So the answer is not to gate everything at equal cost. It is to gate hardest where being wrong is most expensive. The official statement. The public-facing message. The published guidance a person will act on. Oliver did not need a check on his private notes. He needed one meaningful check on the thing he was about to put into the public record.
What to do
If you are putting generative tools into how your team publishes, do not start with the model. Start with the cost of being wrong.
Decide which of your outputs go to the public. Decide which of those a person will rely on. Decide what check each one must pass before it is published, and whether that check is a person, a model, or both. Make “meaningful human control” mean something at the points that matter, and let the machine extend the checking across the volume a human cannot cover. Write it down before you adopt anything.
The words are cheap now, and they are going to keep getting cheaper. The mistakes are not. What you publish to the public is still the reason they believed you last time, and that has never been cheap to earn or to lose.