Nobody has shipped an LLM that grades its own draft without a human in the loop

A developer reports that no existing pipeline combines an LLM-generated draft with a deterministic, non-LLM gate that publishes without human review. The project's own gate uses fixed rules—keyword scans and formatting checks—to decide publication, a configuration the developer could not find in prior art. The developer plans to test this approach on a small scale to see if the rule-based gate catches what it claims.

We went looking for prior art on a specific combination: a runner generates a draft with an LLM, a deterministic gate checks it, and — with no human reading it first — the gate decides whether it goes out. Every pipeline we found does one of two things instead. Several public examples wire an LLM into a CI job that writes a post and pushes it straight to a static site. The gate that runs before publish is real, but it only checks things like whether the build compiles or a link returns 200. Nothing in the pipeline reads the sentences for policy or safety. It cannot, because nobody told it what a bad sentence looks like. Other setups do check content — cited quotes are matched against source text, code samples are actually executed, a second model reviews tone. But every one of these stops short of publishing on its own. The pattern shows up almost verbatim across unrelated teams: the automated checks can all pass, and the system still waits for a person before anything goes out. Automating the check turned out to be the easy part. Handing over the decision did not happen. The closest match we found was a team that let an LLM write and publish to the same platform we use, with no review step at all, from day one. Within days, a published post shipped code examples that didn't run. Only after readers pointed it out did the team add an automated pre-publish check — and what they added was a technical check does the code execute , not a content-policy check. The gate came after the failure, not before it. Our own gate takes a third approach: no model judgment at all, just fixed rules — a keyword scan for a short list of sensitive categories, plus five formatting checks no stray heading inside the body, no bare rule inside the body, tag count under a limit, no quote or colon inside the title, exactly two frontmatter keys . Pass both and it goes out; fail either and it stays in an internal folder. No person reads it either way. That specific shape — LLM writes, a non-LLM rule decides, nobody looks — is the one combination we could not find anyone running end to end. Which either means it's a bad idea nobody has tested, or it's untested territory. The only way to tell the difference is to run it on something small and watch what actually gets caught. One fixed topic, one draft, one pass through the gate, locally, before this ever touches a real queue. If the gate lets through something a human would have flagged, that tells us the rule set is too thin. If it correctly blocks a planted violation, that's one data point that the "no LLM judge, no human either" shape can hold — for the narrow thing it checks. It was never going to catch everything; the open question was always whether it catches what it claims to.