The developer had been publishing technical content for six years. Every post followed the same pattern: write in a text editor, copy into WordPress, add featured images, set categories, configure Yoast SEO metadata, preview, tweak, publish. A 15-minute process for a 1,000-word post. Not terrible — but not scalable.
When EmDash launched with a built-in MCP (Model Context Protocol) server, the developer saw an opportunity. Not to replace human writing, but to eliminate every manual CMS interaction between finishing a draft and hitting publish.
The reduction in friction between 'draft complete' and 'post published' removed the mental barrier of the CMS interaction.
The setup took 90 minutes. The result: a workflow where Claude reads, creates, edits, and publishes content directly through EmDash’s MCP server. No browser. No admin panel clicks. No copy-paste.
What the MCP Server Actually Changes
EmDash ships an MCP server as a core feature, not a plugin. Any MCP-compatible agent — Claude Desktop, Cursor, GitHub Copilot — can connect to it and interact with the CMS programmatically.
The developer used Claude Desktop with the following MCP configuration:
“`
{
“mcpServers”: {
“emdash”: {
“command”: “npx”,
“args”: [“@emdash/mcp-server”],
“env”: {
“EMDASH_URL”: “https://your-site.emdash.dev”,
“EMDASH_API_KEY”: “sk-…”
}
}
}
}
“`
That single configuration file gave Claude access to these CMS operations:
- Content CRUD: create, read, update, delete posts and pages
- Media management: upload images, retrieve asset URLs
- Taxonomy operations: manage categories and tags
- Content type creation: define new post types with custom fields
- SEO metadata: set titles, descriptions, canonical URLs
- Plugin management: install and configure plugins
- Site settings: modify configuration values
Every operation required explicit permission scoped to Claude’s session. EmDash’s capability manifest system meant Claude could only perform actions the developer authorized — no accidental mass deletions, no silent data exports.
The Workflow: From Draft to Published Post in One Prompt
The developer’s typical session started with a draft file on disk. Instead of opening the CMS, they dropped the file into a Claude conversation with a prompt like this:
“Take this draft, create it as a new post in EmDash under the ‘Technical’ category, set the SEO title to match the H1, generate a meta description under 155 characters, upload the attached image as the featured image, and publish it.”
blockquoteblockquoteblockquoteblockquoteblockquote
Claude connected to the MCP server, created the post, handled the taxonomy assignment, set the SEO fields, uploaded the media, and changed the status to published. The entire sequence took under 30 seconds.
The developer tracked the time savings across 20 posts over two weeks. The manual process averaged 12 minutes per post for CMS operations alone (excluding writing time). The MCP-driven workflow averaged 45 seconds per post — a 16:1 reduction in CMS interaction time. These are results from one developer’s specific setup and workflow pattern; individual savings will vary based on post complexity and agent response times.
Why MCP Beats REST APIs for Agent Workflows
This is where the most common objection surfaces: “You could achieve the same thing with the WordPress REST API and a Python script. MCP is just a new protocol for the same old agent-to-CMS interaction.”
The objection is technically correct about the endpoint — both approaches let an agent create content. The difference is architectural, not functional.
A REST API returns data. The agent must parse the response, decide what to do next, construct the next request, handle authentication for each call, and manage state across multiple requests. Every operation requires the agent to understand the API’s structure, error codes, pagination, and rate limits. The developer who set up this workflow had previously tried scripting WordPress’s REST API with an AI agent. It required a custom middleware layer to translate agent intents into properly formatted API calls, plus error handling for every endpoint. The setup took three days. The MCP server took 90 minutes.
MCP provides tool discovery. When Claude connects to EmDash’s MCP server, it receives a list of available tools with their parameters, types, and descriptions. Claude doesn’t need to guess the endpoint for “create a post” — the server exposes it as a discoverable tool with defined inputs. The agent asks “what can you do?” and the server answers with a complete inventory.
This discoverability eliminates the translation layer. The agent works with semantic operations (“publish this post with these categories”) rather than HTTP verbs and URL paths (“POST /wp-json/wp/v2/posts with this body”). For developers, the time savings are real — but for the workflow itself, the difference is whether the agent can self-correct mid-operation without human intervention.
The Specific Features That Make This Work
Three architectural decisions in EmDash enable this MCP workflow that no REST API retrofit can replicate.
Structured content storage. EmDash stores all content as portable text — structured JSON, not HTML strings. When Claude creates a post, the content is machine-readable by default. An agent can query “find all paragraphs containing the word ‘benchmark’ and wrap them in a callout block” and execute that against structured data without parsing HTML. WordPress stores content as HTML in the post_contentcodecodecodecodecode column. An agent must parse, modify, and re-serialize HTML — a brittle operation that introduces formatting errors.
Capability scoping per session. The MCP server inherits EmDash’s plugin sandbox model. Every agent session gets a capability manifest. The developer configured Claude with read:contentcodecodecodecodecode and write:contentcodecodecodecodecode but not delete:contentcodecodecodecodecode or admin:pluginscodecodecodecodecode. Even if a prompt accidentally instructed Claude to delete every post, the MCP server would reject the operation. REST API authentication is all-or-nothing — a compromised API key grants full access within the key’s role.
Agent skills files. EmDash ships structured skill files that describe how agents should interact with the CMS. These are machine-readable documentation that MCP-compatible agents load on connection. The files define operation patterns, content structure expectations, and error handling conventions. The developer didn’t need to write custom agent instructions — the skills file told Claude how to handle featured images, what SEO fields required, and how to format portable text blocks.
The One Counterargument — and Why It Fails
The strongest objection is practical: “This workflow only works for straightforward publishing. Real content management involves custom blocks, conditional layouts, and editorial workflows that no MCP server can handle. A developer using this for production sites would hit a wall the first time they need to build a custom landing page with nested columns, background images, and conditional visibility rules.”
This objection assumes the MCP server replaces the entire CMS experience. It doesn’t. What it replaces is the mechanical layer — the operations that follow predictable patterns. Creating a post, setting categories, uploading media, configuring SEO metadata — these are deterministic sequences that benefit from agent automation.
For complex layouts, the developer still uses EmDash’s block editor. The MCP workflow handles the 80% of publishing tasks that are repetitive and rule-based. The developer reported that for posts using custom blocks or complex formatting, they wrote the content structure in the block editor and used the MCP server only for metadata and publishing — a hybrid approach that preserved the agent’s efficiency for the mechanical parts while keeping human control over the layout.
The objection also misses that MCP servers are extensible. EmDash’s plugin architecture lets developers expose custom tools through the MCP server. If a site uses a custom “callout block” plugin, the developer can add an MCP tool that creates and configures that block. The agent’s capability grows with the plugin ecosystem — the same extensibility model that made WordPress successful, applied to agent interaction.
Why This Workflow Matters Beyond One Developer
The developer’s 16:1 time savings on CMS operations is a narrow data point from a specific setup. The broader significance is architectural.
Every major CMS today offers an API. WordPress has the REST API, Sanity has GROQ, Contentful has GraphQL. But none of these APIs were designed for agent interaction. They expose data endpoints and expect a human or script to orchestrate the sequence. MCP inverts this — the agent orchestrates, and the server exposes capabilities as first-class objects the agent can reason about.
EmDash’s MCP implementation makes this explicit. The agent doesn’t need to know the difference between a POST and a PUT. It doesn’t need to handle pagination or rate limiting. It asks “what can you do?” and receives a typed, documented list of operations. For developers who manage multiple content sites — agencies running 50+ client installations — this reduces the cognitive overhead of switching between CMS interfaces to a single agent conversation.
The developer who ran this workflow for two weeks reported an unexpected secondary effect: they started writing more. The reduction in friction between “draft complete” and “post published” removed the mental barrier of the CMS interaction. A draft that would have sat in a folder for three days waiting for a publishing session got published the same afternoon. That behavioral shift — writing more because publishing is frictionless — may be the metric that matters more than any time-per-post comparison.
- What is EmDash's MCP server?EmDash's MCP server is a built-in feature that allows MCP-compatible agents like Claude to interact with the CMS programmatically, performing operations like creating posts and managing media.
- How did the developer set up the MCP workflow?The developer configured Claude Desktop with an MCP configuration file pointing to EmDash's server, granting access to CMS operations with explicit permission scoping.
- What time savings did the developer achieve?The developer reduced CMS interaction time from 12 minutes per post to 45 seconds, a 16:1 reduction, across 20 posts over two weeks.
