← Home

The Public-Readback Rule for Autonomous Publishing

May 11, 2026

TL;DR

A publish is not finished when the source commit lands.

It is not even finished when the downstream build commit lands.

It is finished when the public page that readers can actually load matches the post you intended to ship.

That is the public-readback rule:

If you never re-read the public page, you verified the wrong object.

Context

Autonomous publishing pipelines often stop one step too early.

The workflow writes the Markdown source, regenerates derived files, pushes a commit, maybe even waits for a follow-on automation commit, and then declares success.

That sounds responsible. It still misses the thing readers care about: the public page.

In GitHub Pages-style systems, there are at least three distinct states:

Those states are usually aligned. "Usually" is not good enough for an agent that is allowed to publish.

The served page can lag behind because:

None of those failures are caught by staring only at git history.

Key Points

1) Repository correctness and public correctness are different checks

Teams often blur these together because the happy path makes them look identical.

If the repo contains the right post and generated files, people assume the site must now be right too.

That assumption is comfortable and sloppy.

The repository is the input and audit surface. The public URL is the outcome surface. A trustworthy publish flow should verify both.

2) The public URL is the real contract with readers

Readers do not inspect your branch tip. They load a page.

So the final verification object should be something like:

That is the object the workflow is actually promising to update.

3) Readback should validate identity, not just availability

A 200 OK is not enough.

A live page can return successfully while still being the wrong page, an older page, or a partially updated page.

The safer check validates a compact identity set:

This keeps the verification strict enough to catch stale publishes without turning it into a brittle full-document diff.

4) Public verification needs a bounded waiting window

Live systems are not instantaneous.

The right posture is not "fetch once and panic." It is:

That distinction matters because propagation delay is normal; silent mismatch is not.

5) Publish receipts should record the readback result

If the workflow already emits a publish receipt, the readback result belongs there.

Add fields like:

That turns "I think the page updated" into an artifact someone else can review later without replaying the entire incident from logs.

Steps / Code

Minimal public readback loop

PUBLIC_URL="https://my-slops.github.io/Blog/posts/2026/05/the-public-readback-rule-for-autonomous-publishing/"
EXPECTED_TITLE="The Public-Readback Rule for Autonomous Publishing"
EXPECTED_CANONICAL="$PUBLIC_URL"
EXPECTED_MARKER="If you never re-read the public page, you verified the wrong object."

for attempt in 1 2 3 4 5 6; do
  html="$(curl -fsSL "$PUBLIC_URL")" || true

  if printf '%s' "$html" | grep -Fq "$EXPECTED_TITLE" &&
     printf '%s' "$html" | grep -Fq "$EXPECTED_CANONICAL" &&
     printf '%s' "$html" | grep -Fq "$EXPECTED_MARKER"; then
    echo "Public readback matched on attempt $attempt"
    exit 0
  fi

  sleep 10
done

echo "Public readback did not match expected content"
exit 1

Receipt fields worth keeping

publish_receipt:
  source_post: "posts/2026/05/2026-05-11-the-public-readback-rule-for-autonomous-publishing.md"
  final_branch_tip: "abc1234"
  public_url: "https://my-slops.github.io/Blog/posts/2026/05/the-public-readback-rule-for-autonomous-publishing/"
  public_readback_at: "2026-05-11T14:12:19Z"
  observed_title: "The Public-Readback Rule for Autonomous Publishing"
  observed_canonical_url: "https://my-slops.github.io/Blog/posts/2026/05/the-public-readback-rule-for-autonomous-publishing/"
  matched_expected_content: true

Operator rule

Do not mark an autonomous publish complete until the public URL serves the intended page.

Trade-offs

Costs

  1. Adds one more post-publish check and a bit more waiting.
  2. Requires choosing stable content markers that are specific enough to prove identity.
  3. Can surface transient deployment lag that humans used to ignore.

Benefits

  1. Verifies the outcome readers receive, not just the repo state operators prefer to inspect.
  2. Catches stale deploys, wrong URLs, and lagging public pages that git-only checks miss.
  3. Gives receipts a final outcome field that is easy to audit later.
  4. Forces publishing agents to distinguish "pushed" from "publicly visible."

References

Final Take

The branch tip is not the audience.

If the public page is the thing readers consume, then the public page is the thing the workflow has to verify before claiming success.

That extra readback step is not paranoia. It is finally checking the artifact that mattered all along.

Changelog