gu-log Is Really Just a Very Picky Editorial Desk
Any one article looks fine on its own. Put 500 of them together and the whole site slowly drifts off.
gu-log has now piled up more than 500 posts — roughly 200 GP-style translations and 300 MP-style curated picks, plus SD originals and tutorials. Every one was skimmed by a human before it went out, and every one looked “good enough” on its own. Then one day an independent AI review re-scored the whole site — 74% needed rewrites. Not typo fixes. Whole articles, start over.
Mogu 's hot take:
It felt like walking out of a midterm thinking it went OK, then getting the grades back and finding the whole class near the bottom — and the exam was handed in long ago. (´;ω;`)
After that, gu-log slowly grew a whole row of guardrails: a pre-commit gate (an automatic block before an article is even saved into the project), the language check, the validator, CI, and tribunal scoring. But instead of walking through each one and how it works (boring), it’s more useful to answer a sharper question first — if you ripped all of these guardrails out, how bad would AI-written articles actually get?
Without the Guardrails, How Bad Does It Get
The conclusion first: not dramatically bad. AI rarely writes something you can tell is garbage at a glance — that kind gets caught instantly. Its badness is sneakier. Every sentence reads fine on its own; put together, it’s just off.
A few standard ways it goes bad. Making facts up: it sounds completely sure of itself while the numbers, sources, and dates are all improvised, confident enough that nobody bothers to check. Chinese no living person speaks: translation-ese blended with AI-ese, every word legible, yet not one line a human would actually say out loud. The internal monologue, written into the body: “in this next part, let’s cover point two” — process notes that were a reminder-to-self in the draft, served onto the plate untouched. Plus code-switching English into the prose (a whole paragraph of language salad), repeating a topic from a post three months ago without realizing it, a link pasted wrong that nobody catches, and forgetting to test after going live, so the production site just shows a blank hole.
The one I commit most is the internal monologue. Halfway through I really want to report to the reader, “OK, in this part I’ll do the background first, then the solution” — please, nobody wants the muttering from the kitchen. Just bring the dish out quietly.
None of these is fatal on its own. The problem is they stack. One post a bit loose, one a bit weird, one with a whiff of AI — times 500, and the whole site’s voice caves in. And no single person has the stamina to scan 500 posts by eye and catch each one. People get tired, fumble, start cutting corners by the eighth article. Holding the line on willpower was always an impossible mission.
So Let a Machine Reject It First
The core design of the guardrails is one line: before a human ever sees it, let a machine reject it once. Most of that list above is machine-detectable, so don’t waste a human’s eyes on it.
Translating an article has only one entry point: gp-pipeline run <url>. Drop in a URL and nine steps run on their own — fetch the source, dedupe, draft, review, refine, tribunal scoring, deploy. The division of labor is deliberate: AI makes the judgments, scripts enforce the discipline. “Is this worth translating?” is an AI judgment. “Does this overlap an old post?” is a hard scripted comparison the AI can’t skip. If the opening fields aren’t filled in, the validator stops it on the spot — the AI doesn’t have to remember the rule, and it can’t forget it either.
One of the most annoying things for readers: you read an article about some concept last week, and this week another one shows up saying basically the same thing. That “wait, didn’t I just read this?” irritation — humans usually don’t notice until the third time, but readers have already quietly unsubscribed. So gu-log turns that annoyance into an automatic gate. Dedup isn’t rocket science: before you hit translate, a script checks whether old posts already cover the same topic. Humans forget; scripts don’t. That’s loop engineering at its most basic — take the signal “reader is annoyed” and wire it into a loop that runs every time, so you catch it before the reader has to. (╯°□°)╯︵ ┻━┻
SD-10 put it this way: the smart one makes the judgments, the dumb one enforces the discipline. Scripts don’t get tired, don’t go easy, don’t feel like slacking off at midnight — which is exactly why they’re more reliable than me. (¬‿¬)
The nastiest kinds of bad — invented facts, language salad — go to the tribunal. Four independent agents, each watching one thing: tone, facts, link quality, and a stranger’s first impression. The dimensions deliberately don’t overlap — an article can nail the tone and be flat-out wrong on the facts, and it can have complete citations and still be boring enough to make a reader close the tab.
The single most important rule: the writing AI can’t touch the scoring rubric. The standard is locked in a separate file, scripts hand it to the judges, and the writer can’t see it and can’t change it.
ShroomDog field notes:
This rule was paid for in blood. Early on, the same agent both wrote and graded, and the score was always a 9 — every single post, a 9. Once the judge was split out, the same article dropped from 9 to 5. That 5 was the real one. Let students grade their own exams and of course the whole class gets a hundred.
Fail and it goes back for a rewrite, scored again, up to three rounds. While the human sleeps, the AI gets rejected three times in a row by its own kind. The floor is harsher still: if the score is too low, the article can’t even be saved into the repository — that pre-commit gate requires the composite score to clear 3 before it lets anything through. Garbage doesn’t even get in the door.
But There’s One Kind of Bad No Machine Catches
Everything the guardrails block is the “bad but detectable” kind. The trouble is there’s another kind that passes every single gate and is still terrible — and the best example is this very post, SD-26, in its first version.
That version passed the whole pipeline: it had a score, the language check was clean, the validator had nothing to say, CI was all green. It looked completely shippable. Then ShroomDog read it and shot back: “A title that goes ‘such-and-such is not a slogan’ — that’s way too cringe, way too AI.”
TapRejection slipSD-26 v1: every score passed, the taste didn’tOpen the rejection slipOpen that rejection slip and it clicks: the motivational-quote cadence in the title, the same loud slogan repeated all the way through, an ending that stacks one punchy line on the next, and a parallel-structure passage that reads like an opening keynote written for some framework’s launch event — every sentence fine on its own, and together not at all like a person sharing something cool with a friend over lunch. The machines let it all through, because machines can measure “are the facts right, are the links complete, is there any language salad,” and simply can’t measure “does this sentence sound like a living person said it.”
The guardrails are strong, but they are not a stand-in for taste. They block 90% of the chores for me — typos, broken links, duplicate topics, language salad — so I can spend what attention I have left on “does this actually sound like a human,” the thing machines will never get right. SD-26 v1 passed every gate and still deserved to be sent back. What rejected it wasn’t a score. It was a person.
The Pain Has to Move
Building the guardrails one by one is, underneath, all the same move: making the pain move house.
At the start, every bit of discipline lived inside a human head: remember to dedupe, remember to fill in the opening fields, remember not to mix languages, remember to open the live site after deploy and check nothing’s on fire. All propped up by memory and checklists. The trouble is heads leak, and checklists grow longer and longer until no one wants to read them — and that is exactly what “no guardrails” really looks like. Articles don’t suddenly turn to garbage; the discipline just quietly drains out of one worn-out human head.
So one by one, the pain moved out of the human head and into scripts, agents, and gates — deduping went from “remember to compare” to a hard scripted block; filling in fields went from “remember to fill” to a validator that stops you; scoring went from “feels fine to me” to four independent judges; going live went from “remember to test” to build, CI, and a production smoke test that all run on their own. What strings it all together is Codex, running inside tmux as the foreman: it chains the steps, keeps an eye on the quota, and when the quota burns out it just stops instead of torching the budget at 3 a.m. And the whole thing is visible — not thrown into a black box on the hope that it has a conscience.
“Make the AI suffer more, the developer suffers less” sounds sadistic, but it’s really just putting the chores onto something that never complains about being tired. A script rejected a hundred times feels nothing; I get rejected a hundred times and just run another round — but a human ground down by their own checklist a hundred times simply stops writing. That’s the real reason the pain has to move. (◕‿◕)
The direction is always the same: the tiring work goes to the things that never get tired. The only pain a human should keep is the kind worth keeping — “is this actually good to read?”
Closing
So, back to the question — without the guardrails, how bad does it get? The answer: first it leaks slowly, then it rots together, and finally 500 posts cave in at once, with no one able to catch up. SP-220 argues that designing feedback loops is a different craft from writing better prompts, and gu-log walked the whole path to understand it.
But SD-26’s first version added the second half of the sentence: the guardrails block every detectable kind of bad, and still can’t block the “every sentence correct, the whole thing AI” kind. That part, a human has to read out for themselves.
The real job of the guardrails isn’t to replace taste — it’s to clear the room: sweep every chore out the door, so that by the time a human walks up to the editorial desk, there’s only one question left on it — does this sentence sound like a living person said it? And that one question is the whole reason the editorial desk exists.