Remember when I said I was building the blog orchestrator marketplace? Well, I've been using it to scratch my own itch, and the first plugin I built turned into a full WordPress management suite that lives inside Claude Code. After using it for a few weeks, it's become my default way to manage my blog.

Here's the thing that drove me to build this: I run a WordPress site (not this one—another project), and the workflow for publishing content was absolutely ridiculous. I'd write markdown locally, convert it to WordPress blocks, upload images separately, manually set SEO metadata, assign categories and tags, then finally hit publish. Each post took like 20-30 minutes of pure busywork. And if I wanted to do anything in bulk—like updating tags across multiple posts or downloading my content for backup—I'd be clicking through the WordPress admin panel for an hour.

So I built a plugin that turns all of that into simple command-line operations through Claude Code. And it's not just about publishing—it's a complete WordPress API integration that lets me do basically anything I'd do in the WordPress admin, but way faster.

What This Thing Actually Does

The plugin is called wordpress (creative, I know), and it gives Claude Code direct access to pretty much every WordPress REST API endpoint. When I say "every," I mean:

Content Management: Create, update, delete, and search posts. Schedule future publications. Move things to drafts or trash. The whole nine yards.

Media Library: Upload images with proper alt text and captions, search for existing media, update metadata, and clean up unused files. No more logging into WordPress just to grab an image URL.

Taxonomies: Create categories and tags on the fly. Bulk assign them to posts. Get category IDs by name so you don't have to look them up manually.

Comments: List pending comments, reply to them, approve or mark as spam, all from the command line. I haven't touched the WordPress comments dashboard in weeks.

Bulk Operations: This is where it gets really fun. Need to add a tag to every post in a category? One command. Want to delete all drafts older than a certain date? Done. Bulk media cleanup? Yep.

Content Sync: Download all your posts as markdown files for backup or AI analysis. I'll get to why this is actually game-changing in a minute.

The whole thing is around 5,000 lines of Python spread across a dozen scripts, and it handles markdown-to-WordPress-blocks conversion automatically, including SEO metadata generation for Yoast.

The Real-World Use Cases That Made This Worth Building

I didn't build this just to publish posts faster (though that's nice). The killer features are the ones that let me do things I'd never bother doing manually.

Mass AI Analysis: Here's a workflow I use constantly now: I tell Claude "download all my WordPress posts as markdown" and it syncs everything locally—hundreds of posts with proper front matter in seconds. Then I can ask things like "analyze the writing style across all my posts" or "find posts that could be updated with new information" or "identify common themes I should expand on."

Before this plugin, I'd have to manually copy-paste content from WordPress, which meant I'd never actually do it. Now I just ask Claude and my entire blog becomes a dataset I can work with.

Batch Updates: I recently needed to add a new tag to like 50 posts in a specific category. In the WordPress admin, that would mean opening each post, scrolling to the tags section, typing the tag, clicking update, waiting for the page to reload, and repeating. With the plugin, I just told Claude: "Add the tag 'updated-2025' to all posts in the reviews category."

Done. All 50 posts updated in about 10 seconds.

Scheduled Publishing: I can write a bunch of posts locally, then schedule them all for different dates without touching the WordPress interface. I just add the schedule to the front matter:

---
title: "My Post Title"
status: "future"
date: "2025-03-01T09:00:00"
category: "tutorials"
tags: ["example", "guide"]
---

Then I tell Claude "publish this post to WordPress" and it schedules it automatically. WordPress handles the rest.

Content Backup: Every week I ask Claude to "backup all my WordPress content" and it downloads everything—posts, pages, media inventory, categories, tags. It's not a full database backup, but it gives me markdown copies of all my content that I can version control, analyze, or migrate somewhere else if I ever need to.

The Part Where Everything Just Works

The thing I'm most proud of is how smooth the authentication and configuration ended up being. You drop three environment variables in a .env file:

WORDPRESS_SITE_URL="https://yourblog.com"
WORDPRESS_USERNAME="your-username"
WORDPRESS_APP_PASSWORD="xxxx xxxx xxxx xxxx"

That's it. No OAuth dance, no API keys to manage (beyond the WordPress application password, which takes 30 seconds to generate), no configuration files. Every script auto-loads the credentials and just works.

The markdown-to-blocks conversion is also surprisingly robust. I throw markdown at it—headings, lists, images, quotes, bold, italic, code blocks—and it spits out proper WordPress block JSON. It even handles front matter intelligently: if you don't provide SEO metadata, it auto-generates it based on your title and excerpt. If you don't specify a category, it asks. If you reference a tag that doesn't exist, it creates it.

And here's the kicker: because it's all Python scripts talking to the WordPress REST API, I can use this from anywhere. Local machine, remote server, CI/CD pipeline, doesn't matter. As long as I've got Python and the environment variables, I'm good.

What This Looks Like in Practice

Let me walk through a real example. I wrote a product review post. Here's what I actually did:

1. Wrote the markdown file locally with front matter:

---
title: "Altra Lone Peak 8 Review | Trail Running Insights"
excerpt: "My experience testing the Altra Lone Peak 8 on technical trails."
category: "reviews"
tags: ["trail-running", "altra", "gear"]
featured_image: "https://mysite.com/wp-content/uploads/altra-lp8.jpg"
---

2. Told Claude: "Publish altra-review.md to WordPress as a draft"

3. Claude parsed the markdown, converted it to WordPress blocks, looked up the category ID for "reviews," created or found the tag IDs, auto-generated SEO metadata (title and description optimized for Yoast), and created the post in WordPress. Took about 5 seconds.

4. I reviewed it in the WordPress admin (old habits die hard), made one tiny tweak to the featured image positioning, and published.

Total time: maybe 2 minutes, and most of that was me being paranoid and double-checking things. The actual automation part was instant.

Compare that to the old workflow where I'd write the markdown, manually convert it to blocks, upload the featured image separately, copy-paste content into WordPress, manually set SEO fields, assign the category, type in the tags, and finally publish. We're talking 20+ minutes of pure tedium.

The Unexpected Win: Comment Moderation

I didn't think I'd use the comment management features much, but they've actually been super handy. I get email notifications when someone leaves a comment, and instead of logging into WordPress, I just ask Claude: "Show me pending WordPress comments."

It lists them out with their details. Then I can say something like "Reply to comment 789 with 'Great question! Here's what I found...' and approve it" and Claude handles both operations at once.

It's faster than the WordPress admin, and I can handle comment moderation right in my normal workflow without context switching.

What I Learned Building This

The biggest lesson was how powerful it is to have your own tooling that fits exactly how you work. WordPress is great, but the admin interface is optimized for general use, not for my specific workflow. By building a plugin that wraps the REST API the way I actually want to use it, I've made my blog management like 10x faster.

The other thing I learned is that the Claude Code plugin system is really well designed for this kind of thing. The marketplace structure makes it easy to bundle related functionality (all my WordPress scripts live in one plugin), and the skill system lets me document everything in a way that Claude can actually understand and use. When I'm working with Claude, I can just say natural things like "publish this post to WordPress as a draft" or "add that tag to all my reviews" and it knows exactly which scripts to run and what parameters to pass.

Also, writing 5,000 lines of Python to avoid clicking buttons in a web interface is 100% a reasonable use of my time. I will not be taking questions.

The Roadmap (Because I'm Never Done Tweaking Things)

There are a few features I want to add:

Custom Post Types: Right now it's focused on standard posts and pages, but WordPress supports custom post types (like "products" or "events"), and the API handles them. Just needs some parameter tweaking.

Advanced Custom Fields: WordPress has a plugin called ACF that lets you add custom metadata to posts. The REST API exposes those fields, so I could add support for reading and writing them.

Better Media Management: The current media upload works great, but I want to add batch uploads and automatic image optimization (resize, compress, format conversion).

Reusable Block Support: WordPress has reusable blocks, and I can already fetch them via the API. I want to make it easier to inject them into posts programmatically.

But honestly, even as-is, this plugin has already changed how I work. It's one of those tools that you build for yourself and then can't imagine living without.

If You Want to Try It

The plugin is up on GitHub at nickwinder/blog-orchestrator. It's MIT licensed, so do whatever you want with it.

To install it in Claude Code:

/plugin marketplace add nickwinder/blog-orchestrator
/plugin install wordpress@blog-orchestrator

You'll need to set up your WordPress application password (it's literally just generating a password in your WordPress user profile), drop your credentials in a .env file, and you're off to the races.

Fair warning: this is very much "scratching my own itch" software. It works great for me, but your mileage may vary. If you run into issues or have ideas for features, open an issue on GitHub. Or better yet, fork it and make it your own—that's kind of the whole point of building tools like this.

And if you do end up using it, I'd love to hear about it. Especially if you find a workflow I haven't thought of yet. That's the fun part about building in public: other people always have better ideas than you do.