The Claude Skill for WordPress Publishing

A Claude skill WordPress publishers can install in one click is the architectural unlock most AI publishing pipelines miss. Specifically, instead of every writing skill reimplementing authentication, the Gutenberg wrap, draft-status logic, and Yoast meta writes, one publishing skill owns all WordPress logic. As a result, the writing skills focus on writing.

This post explains the centralized publishing-skill pattern, what the skill handles automatically, how to install it in Claude Code or Cowork, and the real numbers it produced on a 1,057-issue audit cleanup. Furthermore, it ends with an honest scope list so you know exactly what the skill does and does not solve.

What a Claude skill actually is

A Claude skill is a structured folder containing one Markdown file (SKILL.md) and optionally a references/ folder with deeper docs and a scripts/ folder with executable code. As a result, when you install the skill into Claude Code, Claude Cowork, or Claude Desktop, Claude reads the SKILL.md the first time the user mentions a matching trigger phrase. Specifically, the skill description tells Claude when to load it, and the body tells Claude what to do once loaded.

How a skill differs from an MCP server

The two are often confused. In particular, an MCP (Model Context Protocol) server is a separate process that exposes live tools to Claude over stdio or HTTP. Conversely, a skill is just files Claude reads at conversation time. Specifically, MCP servers are great for live data sources (a database, a calendar, a Slack workspace). Skills are great for codified workflows (publish a blog post, refresh a dependency graph, run an audit). As a result, the two complement each other — a skill can call an MCP server, and an MCP server can be wrapped by a skill.

The centralized publishing-skill pattern

Every team that builds AI publishing pipelines hits the same problem. Specifically, each writing skill (one for blog posts, one for landing pages, one for case studies) ends up reimplementing the same WordPress logic: authentication, the Gutenberg wrap, draft-versus-publish status, Yoast meta payload, image upload, verification. Furthermore, when the Cloudflare User-Agent header changes or the Yoast plugin updates, you have to fix every writing skill in lock-step.

The centralized publishing skill solves this. In other words, one skill owns every WordPress operation, and all writing skills hand off to it at their publish step. As a result, the writing skill no longer cares whether the post goes to WordPress, Substack, or a static site. It only cares about producing good content.

The flow at a glance

writing skill (mkt-* or your own)
    |
    | hand off (HTML body, slug, meta, status)
    v
publishing skill (this one)
    |
    +--> auth (HTTP Basic + Cloudflare-safe UA)
    +--> extract body between markers
    +--> strip change-tracking comments
    +--> wrap in <!-- wp:html --> block
    +--> POST to /wp-json/wp/v2/posts (atomic: body + meta + status + featured_media)
    +--> GET back, verify wrap + meta + markers
    |
    v
WordPress (self-hosted .org)

The arrow only goes one way. Specifically, the writing skill does not know how the WP API works; the publishing skill does not know what content the post contains. As a result, you can swap either side without touching the other.

What the Claude skill WordPress publishers install does, and what it needs

This section answers three questions back to back: what the skill does, what it requires from your site, and what its output looks like. As a result, you can decide in two minutes whether it fits your stack — before installing anything.

What it does (six capabilities)

What you need (three prerequisites)

The first time you activate the skill, it walks you through these prerequisites conversationally. In other words, it asks for the site URL, your username, and the Application Password (with step-by-step instructions for generating one). Furthermore, it then runs a live sanity check against your site — confirms the REST API is reachable, your user has Editor capability, and the Yoast snippet is active. As a result, you go from “skill installed” to “first draft posted” in roughly five minutes.

What the output looks like

Every post created or updated by the skill ships with its body wrapped in a Gutenberg HTML block. Specifically, the wrap is <!-- wp:html --> ... <!-- /wp:html --> — a Custom HTML block that the WordPress block editor leaves alone on every save round-trip. As a result, your custom CSS, callout boxes, and JSON-LD schema survive every editor save without being fragmented or re-parsed.

<!-- wp:html -->
<style>
  .post-XX-wrap h2 { ... }   /* scoped to the article wrapper */
</style>

<div class="post-XX-wrap">
  <p class="lede">Your article body lives here ...</p>
  ...
  <script type="application/ld+json">{ ... }</script>
</div>
<!-- /wp:html -->

Two consequences. First, your inline CSS lives inside the block, scoped to a per-post wrapper class so it cannot leak into the WordPress theme’s header or sidebar. Second, anyone editing the post in the block editor sees a single Custom HTML block they can edit safely — not a fragmented mess of paragraph and heading blocks. In other words, the output is round-trip-safe by design.

The seven production quirks the skill bakes in

Beyond the six capabilities and three requirements above, the skill bakes in seven production-only quirks that cost hours to debug if you hit them yourself. Specifically, each of these is a one-line fix once you know about it — and a half-day of head-scratching if you do not.

The headline feature: Yoast meta in one POST

Until recently, writing Yoast SEO meta required a manual paste into the WP admin Yoast box after the API push. Specifically, Yoast does not expose its meta fields through the REST API by default, so writes to _yoast_wpseo_metadesc, _yoast_wpseo_focuskw, and friends silently no-op. As a result, every automated pipeline ended with a human clicking through WP admin to paste meta.

The fix is a 22-line PHP snippet installed via the Code Snippets plugin. Furthermore, that snippet registers each Yoast field with show_in_rest: true, so the standard REST meta field becomes the write path. The skill ships with the snippet inside references/yoast-meta.md and warns you when an empty Yoast field is detected after a push — a clean signal that the snippet is missing. The full pattern plus the additional-keyphrases (Yoast Premium) extension is documented in Automate Your Yoast Meta Description.

# one POST writes the body, status, featured image, and ALL Yoast meta
import requests
auth = ("claude-bot", APP_PASSWORD)
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) ..."}
payload = {
    "status": "draft",
    "content": gutenberg_wrapped_body,
    "featured_media": media_id,
    "meta": {
        "_yoast_wpseo_metadesc":      "Short, keyphrase-led, under 135 chars.",
        "_yoast_wpseo_focuskw":       "claude skill wordpress",
        "_yoast_wpseo_focuskeywords": '[{"keyword":"automate WordPress publishing AI","score":""}]',
        "_yoast_wpseo_title":         "Custom SEO title (optional)",
    },
}
r = requests.post(WP + "/wp-json/wp/v2/posts", auth=auth, headers=headers, json=payload)
r.raise_for_status()

That single call replaces five WP-admin tabs and ninety-six form fields per post. By contrast, the manual flow burns thirty seconds per post on copy-paste alone, so a fifty-post batch becomes a half-hour click-through that the API does in twenty seconds.

How to install it in Claude Code, Cowork, and Desktop

The skill is a standard Anthropic Agent Skill bundle. Specifically, the same artifact installs into Claude Code, Claude Cowork, and Claude Desktop because all three read the same SKILL.md format. Furthermore, the install path differs per environment, but the skill itself is identical across all three.

Claude Cowork (recommended for non-developers)

Open Cowork and go to Settings → Customize → Skills. Click + Add skill, choose Install from file, and upload the .skill archive. As a result, the skill appears in the Skills list with a toggle. Likewise, toggling it off disables the skill without uninstalling.

Claude Code (developers)

Drop the entire skill folder into ~/.claude/skills/wp-publish/ for user-scoped install, or into <your-repo>/.claude/skills/wp-publish/ for project-scoped install. Furthermore, restart Claude Code so it re-scans the skills directory.

Claude Desktop

Same path as Claude Code — drop the folder into ~/.claude/skills/ and restart. Specifically, the desktop app uses the same skill loader as the CLI.

Total time once you have an Application Password ready: roughly five minutes for someone who has installed a skill before, fifteen to thirty minutes for first-time users. In other words, the bottleneck is the first-run setup walkthrough, not the install itself.

First-run setup and a 60-second test

The first time the skill activates in a Claude conversation, it asks for three things in plain language: your WordPress site URL, your username, and an Application Password. Specifically, it walks you through generating the Application Password inside WP admin (Users → Profile → Application Passwords), waits for you to paste it, and saves all three values to a single JSON file. As a result, you never have to find the credentials path or hand-edit a config file.

Furthermore, the skill then runs a live sanity check against your site. In particular, it hits three endpoints: the REST API root (confirms Cloudflare is not blocking), /users/me (confirms authentication and that your user has Editor capability), and one recent post in edit context (confirms whether the Yoast Code Snippets prerequisite is active). As a result, you find out the moment you have a misconfiguration — not when the first publish silently fails.

After setup, the simplest sanity check is a read-only call. Specifically, ask Claude: “Find the post with slug hello-world on my WordPress site.” The skill returns the post ID, status, and edit URL. The next step is a write test that stays safe: ask Claude to “save a tiny test post as a draft — just one paragraph that says ‘test draft from wp-publish.’” As a result, you have a draft you can delete from WP admin in one click.

Real numbers from the 1,057-issue cleanup

This skill was extracted from a real session that turned a 1,057-issue Ahrefs Site Audit into a three-hour cleanup. Specifically, it ran every WP operation in that audit cleanup, and each operation type now has its own deep-dive post. As a result, the table below cross-references each volume to the specific workflow post that explains the underlying technique.

Furthermore, every operation went through the same skill. Specifically, no writing skill needed to know how the WordPress API worked, and no WP-side bug touched more than one file. As a result, when the Cloudflare User-Agent rule needed to change mid-session, fixing it in one place benefitted every downstream operation.

What is NOT yet in scope

Honest list of limits. In particular, naming what the skill does not do is just as important as naming what it does. Furthermore, several of these are deferred by design rather than missing — they are not blockers for the typical use case.

• Yoast SEO score recompute. The numeric score (_yoast_wpseo_linkdex) is computed by Yoast’s JavaScript at editor save. Specifically, posts edited via REST alone have an empty score until a human opens the editor and clicks Update. There is no public server-side API for this.
• Comment moderation. Out of scope for v1.
• XML-RPC fallback. Not used. In effect, REST only — for security and simplicity.
• WordPress.com (managed Automattic). Different REST API, different auth flow. Self-hosted .org only.
• Yoast Premium redirects. The endpoint exists and works. Likewise, the modify guide shows you how to add it as a flag in roughly ten lines of code. Not wired in by default.
• Automated KSES whitelist for Editor role. The skill emits HTML that survives KSES out of the box. As a result, you can keep richer accordion classes only by adding a Code Snippets PHP filter — documented, but optional.

Specifically, every limit above is a deliberate trade-off, not an oversight. In other words, the goal of v1 was a small, reliable surface area. Furthermore, additions land as new flags rather than rewrites, so upgrading is one-step.

How to get it (early-access launch)

The branded version that runs on this site stays in my own stack. Specifically, the generic, brand-agnostic version — packaged with a README, a modification guide, and the production fixes baked in — is on LemonSqueezy. As a result, you can install it, customize the six values that point at your own site, and start publishing in under thirty minutes.

The bundle includes the .skill archive, a README with install steps for all three Claude environments, a step-by-step MODIFY.md covering every customization point, and the Yoast Code Snippets PHP file. Furthermore, the refund window is fourteen days, no questions, through LemonSqueezy — the intent is to remove the buy-and-regret risk for a piece of technical infrastructure.

Where to go next

The skill anchors a wider workflow on this site. Specifically, the rest of the cluster covers each piece in detail:

• The pillar — how the 1,057-issue audit got cleaned up in three hours
• Foundation 1A — how to connect WordPress to Claude via the REST API
• Foundation 1B — the Code Snippets plugin tutorial that makes Yoast meta REST-writable
• Spoke — the Ahrefs triage workflow this skill executes
• Spoke — the Yoast meta description automation this skill packages
• Spoke — bulk image compression to WebP via the same skill
• Spoke — Yoast Premium redirects through the REST API

External references for the technical foundation: the Anthropic Agent Skills documentation for the skill format, the WordPress REST API Handbook for the endpoint reference, and the Code Snippets plugin page for the prerequisite that unlocks Yoast meta writes.

Frequently asked questions

— Lukas