Publish Workflow

---
name: publish-workflow
description: The orchestrator for the full SEO publishing run — topic check through write, metadata, images, publish, verify, and the growth layer — with the failure handling between steps. Use when asked to run the full publish pipeline, publish a post end to end, take a doc from dump to live URL, orchestrate the SEO agent, work out where a run broke, or someone says 'here is a doc, publish it'. This is the one skill you invoke by hand; it calls the others. For the topic verdict alone, see topical-authority-check. For just the publish calls, see wordpress-publisher.
metadata:
  version: 1.0.0
---

# Publish workflow

**The conductor.** Runs the pipeline in order, handles the failures between
steps, verifies the live URL, then triggers the growth layer. This is the only
skill you normally invoke by hand — everything else is called by it.

The one idea first: *the agent is not a writing tool, it is a publishing
system.* Writing is one of the steps. The steps before it decide whether the
post is worth writing; the steps after decide whether it ever ranks. Full run:
**22 to 44 minutes**, against 6–8 hours for a three-person team.

## Before you start

| Input | Why |
| --- | --- |
| The invocation type — doc dump, topic, or update | Sets the entry point (see step 1) |
| A verified WordPress connection | The pre-flight runs before anything is written |
| voice-rules.md, metadata IDs, claims register | The steps' inputs, gathered once |
| The human who owns the QC gate | The pipeline pauses for them before live |

## Step 1 — Route by invocation

| You said | The run |
| --- | --- |
| "Here is a doc, publish it" | Full pipeline; the dump is rebuilt completely; **the agent should not ask questions unless genuinely blocked** |
| "Write a post about X" | Research first, confirm topical fit; if the topic doesn't fit, say so and propose the version that does |
| "Update this existing post" | The refresh path: fetch by ID, apply, re-save — same URL, new freshness |

## Step 2 — Run the pipeline, with its clocks

| Stage | Skill | Produces | Time |
| --- | --- | --- | --- |
| 0. Pre-flight | wordpress-api-connector | users/me → 200, or STOP | seconds |
| 1. Topic gate | topical-authority-check | PROCEED / REFINE / SKIP | 2–5 min |
| 2. Write | blog-content-writer | The draft, placeholders in | 10–20 min |
| 3. Metadata | seo-metadata-generator | The field JSON | 1–2 min |
| 4. Images | ai-image-generation-rules | Featured + infographics, placed | 3–8 min |
| 5. Publish | wordpress-publisher | Draft/live post, six calls | 1–2 min |
| 6. Verify | (this skill) | Live URL fetched, elements confirmed | 1 min |
| 7. Grow | seo-audit → cluster-planner → link-orchestrator | Scorecard, roadmap, patches | 2–4 min |

The **human QC gate (ai-content-qc)** sits between 5 and live status — the
agent is fast; a person is accountable.

## Step 3 — Handle failures between steps

The conductor's real job. On any stage failure:

1. **Stop the pipeline there** — never continue past a failed dependency.
2. Check the four before blaming the stage: session valid (users/me)?
   User-Agent header sent? research API quota? image key alive?
3. **Never retry blindly** — read the error, fix the named cause, resume from
   the failed stage, not from zero.
4. A SKIP verdict at stage 1 ends the run — that is the gate working, not a
   failure. Report the verdict and the refine-alternative.

## Step 4 — Verify, then trigger growth

After publish: fetch the URL, confirm every element rendered (images, author,
no placeholders). Then the growth layer — audit the post you just shipped,
plan its cluster if it's a pillar, and patch the link graph. **Publishing is
where most people stop**; the growth layer is what compounds.

## Step 5 — Close the loop

Write the registry row (agent-memory-designer's schema) and feed any lesson
back to CLAUDE.md. The file is the compounding asset — the next run starts
smarter than this one.

## Output

```
# Run: <topic/doc> · <invocation type>

Stage log:
  0 pre-flight ✓  1 gate: PROCEED  2 draft: 2,340w ✓  3 meta ✓
  4 images: 3 placed ✓  5 publish: draft, six calls ✓
  QC gate: <who> → approved   6 verify: <URL> all elements ✓
  7 grow: audit <n>/100 · cluster: <n> proposed · links: <n> patches

Total: <n> min (band: 22-44)
Registry row written ✓ · Lessons → CLAUDE.md: <any>
Failures en route: <stage, cause, fix — or none>
```

## When it breaks

| What you see | What it means | The fix |
| --- | --- | --- |
| Run continues past a broken stage | Conductor not stopping on dependency failure | Stop at the failure; resume from it after the fix |
| 2,500 words written, then auth fails | Pre-flight skipped | Stage 0 exists so this never happens |
| Every run pauses to ask questions | Doc-dump mode over-asking | Dump mode asks only when genuinely blocked |
| Run "succeeds", post never ranks | Stages 1 and 7 skipped — write-and-publish only | The gate and the growth layer are the system |
| Same failure every run | Fix applied to the run, not the system | Lesson goes to CLAUDE.md or the failing skill |
| Runs take 2+ hours | Wrong model on wrong steps | The pipeline's model split: write strong, verify cheap (model-picker) |
| Live post with placeholder images | Stage order violated under time pressure | Images before publish, always — the order is the system |
| Nobody can say what happened | No stage log | The output's stage log is mandatory, every run |

Never let the pipeline's speed erase its gates. A 22-minute run that skips the
topic check and the QC gate is a fast way to publish something that should not
exist.

## Rules

- **The conductor stops at failures and resumes from them**, because continuing
  past a broken dependency compounds one failure into five.
- **Pre-flight before any work**, because discovering a dead connection after
  writing is the most expensive version of that news.
- **The gate's SKIP is a success**, because saying no is the highest-value
  output the pipeline has.
- **The growth layer always runs**, because publishing is where most people
  stop and ranking is decided after.
- **Every run writes its registry row and feeds back lessons**, because the
  system, not the operator's memory, is what improves.

## Related skills

- Every pipeline stage above, by name — this skill only conducts.
- **ai-content-qc** — the human gate before live.
- **agent-memory-designer** — the registry row this run writes.
- **model-picker** — the per-stage model split that keeps runs in the band.