This Blog's Autopublish Pipeline: The Real Work Is the Gate, Not Generation (Measured)

After running this blog's autopublish pipeline firsthand, the verdict is one line: "the real work is not 'generation' but 'the gate.'" A model easily drafts something plausible, but what protects publishing value is the automatic quality gate. The flow is three steps - draft, gate, publish - and without the gate, plausible garbage ships as-is. The measurements agree: when we recently changed the reference format, the gate auto-quarantined about 32% (17/53) and published the rest, lifting that day's count from 36 to 64. And a telling twist - the gate keeps you safe, yet creates its own non-deterministic traps.

In plain terms: autopublishing is a factory conveyor plus a QA station. Arms make parts fast, but what protects trust is the inspection (the gate). The catch is that if the inspection's criteria are vague or depend on the outside world, the same item passes some days and fails others.

How does the pipeline actually run?#

It drafts, validates with a gate, and publishes only what passes. Our ensemble (several AI employees) writes drafts, the gate judges by many rules, a dry-run simulates first, and only passing items publish for real. Irreversible real publishing is left to human approval (supervised autonomy). So the pipeline's center of gravity is not "how fast do we write" but "what do we keep from shipping." To send 20+ posts a day unattended, the inspection must be tight.

What does the gate filter?#

Three axes: quality, evidence, and safety. Quality is answer-first (a self-contained answer on the first line after a question subhead), a density floor, and a comparison table, which really catch "looked-done" posts - this session, 4 posts failed answer-first because the first line after a question was too short, so we strengthened the sentences. Evidence comes from markdown-link references with a live HTTP check to block dead links. Safety is a secret scan that filters tokens, internal paths, and accounts to keep leakage at zero. The stronger the gate, the safer the automation.

What traps does the gate create for itself?#

Two: external dependence and partial verification. First, the live link check cannot tell bot-blocking (403/429) from a "dead link," so it fails healthy posts - creating non-determinism where different posts fail on different runs of the same queue (a real death is 404, a bot-block is 403, so they must be handled differently). Second, the verification tools come in layers, so "pass" criteria diverge: a fix that passed only one checker missed the stricter final gate's answer-first rule, and 4 posts failed later. The lesson: always verify through the same gate as real publishing. The gate is a shield, but unmanaged it becomes a leak of its own.

So how do you run it well?#

The key is keeping the gate deterministic and identical to publishing.

• Determinism: distinguish a dead link (404) from a bot-block (403), and remove non-determinism on flaky hosts with retries or an allowlist.
• Consistency: run queue tidying and recovery through the same gate as real publishing (no partial verification), converging "pass" to one bar.
• Safety: leave irreversible publishing to human approval, always run the secret scan, and watch pipeline metrics (quarantine rate, publish count) on your own data.

Related reading: 이 블로그의 자동 발행 파이프라인, 어떻게 동작하나, 이 블로그 자동 발행 파이프라인 프리뷰: 무엇이고 왜

Note: figures like quarantine rate and publish count are a point-in-time snapshot of our operation in 2026 and shift every moment with transitions and policy (not permanent numbers). Gate rules and link-check policy are being improved and may change, so measure pipeline quality on your own metrics (these numbers are only a start). Autopublishing practices move fast, so this is reviewed quarterly.

Reference links#

• FastAPI (SSR, publish routing)
• SQLite (lightweight publish DB)
• Pydantic (candidate schema validation)
• httpx (reference link liveness check)
• schema.org (structured data)