Getting a language model to draft a blog post is easy. Getting one to sound like you, and not like generic LLM output, is the hard part. Your own published posts already encode how you write — the sentence rhythm, how you open and close, the structure you reach for, and the tells you avoid. A style guide drawn from that corpus captures both sides: the patterns worth keeping, and the anti-patterns to leave out — the pithy maxims, the "what this means is" frames, the cute closers, the manufactured urgency.
I'd been doing this by hand for my own blog: a long style guide, a section-by-section revision pass against it, and scripts to push to Ghost. ghost-blog-mcp makes it repeatable, and it works from anyone's corpus — a Claude Code plugin that learns your voice from your published posts, drafts in it, revises against the anti-patterns section by section, and pushes a draft to Ghost.
What it does
ghost-blog-mcp connects to your own Ghost site — the one you have an admin key for — and learns how you write from the posts you've already published. It reads that corpus and builds a style guide from it: the voice (audience, tone, structure), the patterns it observes across your posts, and an explicit list of anti-patterns to avoid. If you don't have a corpus yet, a short interview plus a few examples of writing you admire seed the same guide instead.
From there, drafting starts from the guide. You give it a topic; it plans an angle, drafts it in your voice, and self-audits that draft against every anti-pattern before you read it. You revise it section by section, and it pushes to Ghost as a draft — it never publishes; that stays your call in the editor.
It gets more accurate as you publish. Each post you approve is folded back into the guide, so it drafts in the voice of the posts you've actually shipped, not a fixed snapshot.
How it works
The plugin is a set of skills over a small MCP server that wraps the Ghost Admin API:
- setup-ghost connects the plugin to your Ghost site, reading your admin key from a gitignored file and verifying the connection.
- define-voice handles the cold start — it interviews you about your audience, tone, and what to avoid, and pulls in examples of writing you admire — for when you don't have a corpus yet.
- build-style-guide turns your published posts (or that interview and those examples) into a living style guide: a Stated voice section you control, plus Observed patterns and an Anti-patterns list re-derived from the corpus.
- draft-post plans the angle, drafts to a local file in your voice, and self-audits it against the anti-patterns.
- revise-post walks the draft section by section, checking formatting, voice, and accuracy on each one.
- push-draft pull-guards against edits made in the Ghost editor, builds the markdown into Ghost's card format, uploads the feature image, and creates or updates the draft — always as a draft, never published.
write-post runs the whole sequence — draft, revise, push — in one guided pass, or you can use any skill on its own.
flowchart TD
Corpus[Your published posts] --> Build[build-style-guide]
Interview[Interview + examples] --> Build
Build --> Guide[Living style guide]
Guide --> Draft[draft-post + self-audit]
Draft --> Revise[revise-post · by section]
Revise --> Push[push-draft]
Push --> Ghost[Ghost draft]
Ghost -.approved.-> Build
The MCP is what talks to Ghost: it reads the corpus, creates and updates posts and pages, uploads images, and splits the markdown into Ghost's lexical cards so tables and sections become separate editable blocks.
The harder parts
Three pieces turned out to be more involved than "have the model write a post," and each is its own post.
The first is learning a voice faithfully — capturing what's actually yours, not a generic approximation. A cold generation from a corpus can miss the specific rules an author already cares about, so if you have an existing set, the guide is seeded from it: every rule has to survive into the new guide, verified, before the corpus adds anything new.
The second is the revision. The drafting is the straightforward part; the section-by-section pass — reading each section for formatting, voice, and accuracy against the anti-pattern list — is what turns a plausible draft into one that reads like the rest of the blog.
The third is shipping the MCP itself. It passed its tests and then failed to start under npx, twice, for two unrelated reasons behind the same opaque error — a credential-delivery problem and an entry-point bug.
Installing it
ghost-blog-mcp ships in my Claude Code plugin marketplace. Add the marketplace and install the plugin:
/plugin marketplace add schuettc/claude-code-plugins
/plugin install ghost@schuettc-claude-code-plugins
Then connect it to your own Ghost site and learn your voice from what you've published — or run /ghost:define-voice instead if you're starting a new blog:
/ghost:setup-ghost # connect your Ghost site (one-time)
/ghost:build-style-guide # learn your voice from your posts
After that, /ghost:write-post runs the whole flow — draft, revise, and push to a Ghost draft. The repo is github.com/schuettc/claude-code-plugins; this page was drafted with the plugin and edited from there.
Court Schuett