DEV Community

weiwuji
weiwuji

Posted on

After the 861% Rework Spike, the Real Cost of AI Code Is "Nobody Reviewed It" — Content Pipelines Need a Review Gate Too

#ai #agents #llm #engineering

The Pain: I have been producing articles with AI for almost a year. The thing I fear most is not writing slowly — it is writing fast. Fast enough that the question "should this even ship?" never gets asked before the draft is already sitting in the queue. The code world hit this wall first: GitClear's annual report shows AI-assisted code volume up about 4x while the value it delivered grew only 12%; Faros measured code churn up 861% and defect rates climbing from 9% to 54%. The faster you write, the more you rework — that is the price of cheap generation. Yet most of us still fight the new problem with the old tool: asking the writer to look at their own output a second time.
What You'll Learn: A judgment framework you can actually deploy — why judgment, not generation, is the scarce resource; how the code world's merge gate turned review from "a human stares at it" into "the pipeline blocks it"; and how I installed the same logic into content production, where gate zero and 17 physical writing gates grew out of one incident after another. Every mechanism comes with real commands and real output — copy them and they work.

In my previous article about Agent Skills I wrote a line: skills expire; a skill you maintain is a skill that keeps its value. Today I push the same question one step further — when AI batch output becomes the default action, what is standing between the output and your readers?

1. An 861% rework spike is the turning signal of an era

Look at what happened in the code world first.

GitClear's annual report tracked AI-assisted repositories for a year: commit volume grew roughly 4x, but only 12% more of the changes mapped to real value delivered. Faros did the arithmetic in finer detail: AI-assisted teams saw code churn (the amount rewritten after it was written) climb by up to 861%, defect rates rose from 9% to 54%, and unreviewed merges grew 31.3%.

Number cards: AI-assisted repos under pressure. Left card (blue border): code volume x4, but only +12% of changes map to value delivered. Right card (red border): +861% code churn / rework (Faros), defect rate climbing from 9% to 54%, unreviewed merges +31.3%. Teal conclusion bar: generation got cheaper — judgment became the bottleneck

Put those numbers together and one counterintuitive conclusion emerges: generation got cheaper, so judgment became the scarce resource. Code itself is inflating — more commits, more rework, more merges nobody looked at. Addy Osmani makes the same point repeatedly in Agentic Code Review: after the cost of writing code collapsed, the cost of understanding code did not collapse with it — one minute of AI output takes a human about an hour to review.

Code bloat is not the AI's fault. It is a sign that something is missing from the pipeline.

2. The code world's answer: put review in the pipeline, not in people

Inside GitClear's data there is a harder fact: developers did not get lazier — the review action simply has no place in the flow. Merge requests pile up, people only have the last minutes of the workday, and clicking "approve" gets faster and faster. That is not individual laziness; it is a system that keeps pushing inspection onto the most expensive and scarcest resource there is: human attention. I call this review distortion — it was looked at, and nothing was seen.

Once the code world felt the bite of rework debt, the answer was not "everyone try harder" — it was the merge gate: compile review from human self-discipline into a hard constraint inside the pipeline.

# CI gate in a code repo: if it fails, the merge is blocked (illustrative)
ci run --lint --unit-test --build
if [ $? -ne 0 ]; then
  echo "merge blocked: CI failed"
  exit 1
fi
Enter fullscreen mode Exit fullscreen mode

The division of labor between merge gate and human review is explicit: everything that can be written as a rule is checked by the machine first; only the semantic problems the rules cannot catch go to a person. Review was not cancelled — it was moved behind the machine's sieve, so every human glance lands where the machine cannot see.

3. The same crisis in content: AI writing got cheap — who reviews?

Replace the word "code" in the previous section with "content" and every sentence still holds.

My content-production system has run for 276 days at one article per day — the agent drafts, tools draw the figures, scripts push the draft. Volume went up, and so did the problems, and they look exactly like the code world's:

  • On September 7, the title announced a Kill Switch Bill article while the body was the full text of a different piece about DeepSeek's open-sourced Harness — title and body mismatched, and I re-checked it twice without seeing it;
  • An earlier template accident: during a refactor a code-fence marker was dropped, and the closing sections, the golden line and the signature all got swallowed into a code block — WeChat rendered a wall of grey code;
  • On September 8, an icon in a figure pressed into its text and a card overflowed its border — my boss spotted it in one glance, while my generation script could not.

These three accidents share one trait: none of them was "written wrong" — each one was "not caught." AI multiplied content-production capacity by ten, and inspection capacity did not follow, so bad content sinks silently to the reader exactly like an unreviewed merge.

Compile review from "a human stares at it" into "a gate" — only then can content be batch-produced safely. That is the sentence 276 days of rework taught me.

4. Compiling review into a gate: how gate zero grew

Our answer was not a longer checklist. It was compiling the checklist into a script and embedding it somewhere you cannot push past.

The first version of our gates was a document: I wrote a dozen "things to remember before publishing," and every time I published I would "remember to check." It worked exactly as well as every self-discipline rule — it worked when I remembered, and failed the moment I got busy. What actually made it work was moving it out of the prompt and into code.

Now every writing task ends by running this one command:

python3 /root/hermes-harness/scripts/writing_gates.py article-ta-review-gate.md
# expect: 17/17 PASS -> ready to push
Enter fullscreen mode Exit fullscreen mode

And that command is embedded at the top of the push script as gate zero — want to push an article? The script runs the gates for you first, and exits if they do not pass. Physically, there is no way around it:

import subprocess, sys
gate = subprocess.run(
    ["python3", "/root/hermes-harness/scripts/writing_gates.py", md_path],
    capture_output=True, text=True, timeout=120)
if "🎉" not in gate.stdout:      # gate zero: no pass, no publish
    print("blocked: writing gates failed")
    sys.exit(1)
Enter fullscreen mode Exit fullscreen mode

Vertical six-step pipeline: how a publishing gate grows. 01 (blue) AI drafts at 10x speed. 02 (red) Incident: it shipped, not written wrong — Sep 7 title/body mismatch survived two self-checks; a dropped code fence swallowed the closing sections; Sep 8 icon overlap and card overflow. 03 (amber) Root cause into the error ledger — symptom / root cause / fix / status, append-only, 74 entries. 04 (purple) Compile the cause into a gate — each root cause becomes one script-verifiable check. 05 (teal) Gate zero blocks the push — 17/17 PASS or the process exits. 06 (blue) Nightly refeed closes the loop — every 21:00 review pours new errors back. Teal conclusion bar: gates are not designed — they are compiled from incidents

The gates were not designed in one sitting. They grew one incident at a time: after the title mismatch, a title-body consistency check appeared; after the fence bug swallowed the signature, a fence-balance check appeared; after the figure accident, pixel-level layout verification appeared — every figure now runs through a layout verifier that measures right-margin distance, bottom-margin distance, and whether anything collides with the conclusion strip. The root cause goes into the error ledger (symptom / root cause / fix / status, append-only, 74 entries), the check goes into the gates, and the gates grew from 0 to 17. A nightly 21:00 review task pours the day's new errors back in — the loop does not rely on memory, it relies on a scheduled job.

5. The same logic on both sides: merge gate and publishing gate

Put the code repository and the content factory side by side and the structures are almost mirror images:

Side-by-side comparison. Left column (blue header) CODE | MERGE GATE: lint, unit tests and build run first; review happens after the machine's sieve; CI fails and the merge is physically blocked. Right column (teal header) CONTENT | PUBLISHING GATE: 17 writing gates run first — title-body consistency, fence balance, figure layout pixel checks; semantic checks stay human — is the title about the same thing as the article; gate zero fails and the push script exits. Purple bottom card: same — checks compiled from human vigilance into code; different — semantic consistency cannot be caught by rules, the last gate stays human

Code uses a merge gate to stop rework before the merge; content uses a publishing gate to stop accidents before the publish. Both gates do exactly the same job: whatever can be written as a rule is blocked by the machine first; whatever the machine cannot catch is left for human judgment.

The boundary needs to be stated honestly. Our 17 gates catch format, layout and fences — but they cannot catch "is the title about the same thing as the body?" That kind of semantic question relies on a self-check protocol after writing and a human final review before publishing. The gate does not replace people; it frees people from reading for formatting so their attention lands on what the machine cannot see.

Real review is not looking once more. Real review is making bad things unable to pass the gate at all. Judgment is still scarce — it is just finally spent where it belongs.

Closing

An 861% rework spike will not disappear on its own, and the story of 4x code for 12% value will replay in the content world — AI makes everyone produce more, so much more that nobody can read it all.

Whoever compiles judgment into the pipeline first gets the compound interest of this era: the machine handles speed, the human handles correctness.

One-liner: generation got cheaper, so judgment became the scarce resource — compile review from "a human stares at it" into a gate that blocks the pipeline, and only then can content be batch-produced safely.

📖 Further reading from the Practitioner's series

About the author: Wu Ji (无记) — AI & digitalization practitioner focused on Agent engineering, Loop Engineering, and digital transformation. Practical, hands-on tutorials — follow along and it just works.

Top comments (0)