You don’t teach your AI to use EmDash — EmDash teaches your AI. That flips the usual script. Most CMS platforms bolt AI on as an afterthought: a plugin you install, a prompt you tune, a workflow you hand-craft. EmDash, Cloudflare’s spiritual successor to WordPress, ships with a built-in MCP server and a set of structured skills files. The agent reads them once and knows exactly what it can do. No training. No trial-and-error prompting. The CMS comes with its own instruction manual for machines.
EmDash’s AI Skills Files are markdown documents that describe every operation the CMS exposes — create a post, upload media, manage plugins, deploy changes. An MCP-compatible agent (Claude, Cursor, GitHub Copilot) connects to the server, reads the skills files, and can perform those operations using natural language. The agent doesn’t need to guess the endpoint or the parameter format. The skills files provide the schema, the permissions, and the expected output. This means a developer can say “build me a new content type for case studies with fields for client name, date, and testimonial” and the agent executes it — no manual admin clicks.
The CMS comes with its own instruction manual for machines.
What Are Skills Files in EmDash?
Skills files are plain-text documents stored inside the EmDash codebase. Each file describes one capability: how to create a content type, how to import a WordPress export, how to send a test email. They follow the Model Context Protocol (MCP) standard that Anthropic created for AI agent communication. When an agent connects to EmDash’s MCP server, the server presents these files as available tools. The agent reads the tool definitions, understands the input requirements, and can call them directly.
The files are written in a structured format — part schema, part example, part human-readable explanation. Here’s a simplified version of what a skills file for “create content type” looks like:
“`
Tool: create_content_type
Description: Creates a new content type with custom fields.
Parameters:
- name: string (required, unique)
- slug: string (optional, auto-generated)
- fields: array of field definitions
Example:
name: “Case Study”
fields:
- label: “Client Name”
type: text
- label: “Date”
type: date
“`
The agent parses this, maps it to the underlying API, and executes. No custom code required.
Skills Files vs. Traditional CMS Agent Integration
Most CMS platforms that support AI agents require you to either build a custom integration (writing an API wrapper, defining tools yourself) or rely on a plugin that adds a limited set of actions. EmDash’s approach is different: the skills files are part of the core, maintained by the CMS team, and updated as the CMS evolves. The agent always has access to the latest capabilities. The table below shows the tradeoffs:
| Interaction Mode | Setup Effort | Agent Autonomy | Maintainability | Security Model |
|---|---|---|---|---|
| Admin Panel (UI) | None | Low — manual clicks only | CMS updates handled by host | Role-based access only |
| CLI (Terminal) | Install EmDash CLI, auth | Medium — scriptable but requires human to run | Must update CLI version manually | Token-based, scoped by role |
| MCP with Skills Files | One connection setup (MCP URL + token) | High — agent can read, write, deploy autonomously | Skills files ship with EmDash updates | Granular permissions per tool via manifest |
The MCP route gives you the most leverage. Once the connection is configured, the agent can manage the entire CMS — content, plugins, themes — without a human in the loop. The skills files are the instruction set that makes that possible.
Step-by-Step: Connect Your Agent to EmDash Skills Files
1. Deploy EmDash (if you haven’t)
You need a running EmDash instance. Use the playground at emdashcms.comcodecodecodecode (lasts one hour) or deploy to your own Cloudflare account via the GitHub repo. For production, the paid Cloudflare Workers plan ($5/month) gives you sandboxed plugins and full MCP access.
2. Generate an API Token
In the EmDash admin panel, go to Settings → API Tokens. Create a new token with the scopes your agent will need. For full management, select content:readcodecodecodecode, content:writecodecodecodecode, plugins:managecodecodecodecode, and settings:readcodecodecodecode. Copy the token.
3. Configure the MCP Server
EmDash exposes an MCP server at https:///mcpcodecodecodecode. In your agent’s configuration (Claude Desktop, Cursor settings, or custom app), add a new MCP server:
“`
{
“mcpServers”: {
“emdash”: {
“url”: “https://your-site.emdash.app/mcp”,
“headers”: {
“Authorization”: “Bearer YOUR_API_TOKEN”
}
}
}
}
“`
4. Verify the Connection
Ask your agent: “What can you do with my EmDash CMS?” The agent will read the skills files and list all available tools. You should see actions like create_postcodecodecodecode, update_mediacodecodecodecode, list_pluginscodecodecodecode, deploy_sitecodecodecodecode. If the list is empty, check the token scopes and the MCP server URL.
5. Run Your First Task
Now give a real instruction:
“Create a new content type called ‘Projects’ with fields for Title (text), Description (rich text), and Launch Date (date). Set the slug to ‘projects’. Add it to the main navigation.”
blockquoteblockquoteblockquoteblockquote
The agent will call create_content_typecodecodecodecode with the parameters from the skills file, then update the menu via update_menucodecodecodecode. No manual admin login required.
6. Iterate with Confidence
Because the skills files are versioned with the CMS, you can update EmDash and the agent automatically sees new tools. You don’t need to re-train or re-prompt. This is the core advantage: the CMS stays teachable.
Real-World Use Case: Bulk Content Migration
Let’s say you have 500 blog posts in WordPress that you want to move to EmDash. Instead of running the built-in import tool manually (which still requires downloading a WXR file and uploading it), you can instruct the agent:
“Import all posts from my WordPress site at example.com. Use the WXR export URL. Map Yoast SEO fields to EmDash’s built-in SEO fields. After import, create a redirect for each old URL to the new path.”
blockquoteblockquoteblockquoteblockquote
The agent will:
- Fetch the WXR file from the WordPress export endpoint.
- Call
import_wordpresscodecodecodecode (a skill file tool) with the file URL. - Read the Yoast meta from the export and map it.
- Create 500 redirects using
create_redirectcodecodecodecode.
The whole process takes minutes. The agent handles the repetitive mapping and redirection — tasks that would take a developer hours to script.
Why This Changes How You Build Sites
Skills files are not just a convenience. They decouple the CMS interface from the user interface. A non-technical client can still use the admin panel. A developer can use the CLI. An AI agent can use the MCP server. All three paths work because the same capabilities are exposed through separate channels. The skills files are the canonical reference — the single source of truth that each channel reads.
For agencies and freelancers, this means you can hand a client a site and also give them an AI agent that can make changes on their behalf. No more “I need you to log in and update this field.” The agent does it. The client reviews the output. You retain control over the architecture.
The Catch: Skills Files Are Only as Good as Their Definitions
The skills files that ship with EmDash cover the core CMS operations. But if you build custom plugins or themes, you need to write your own skills files for those custom tools. The format is straightforward — markdown with a JSON schema — but it’s an extra step. The EmDash team expects the community to contribute skills files for popular plugins, similar to how WordPress plugin developers document hooks.
Right now, the built-in skills files are enough to run a content site. For anything beyond that — custom e-commerce logic, complex membership workflows — you either wait for the ecosystem to mature or write the skills file yourself. That’s the tradeoff for being early.
- What are Skills Files in EmDash?Skills Files are plain-text documents stored in the EmDash codebase that describe each CMS capability using the Model Context Protocol standard.
- How do Skills Files differ from traditional CMS agent integration?Unlike most CMS platforms that require custom integrations or plugins, EmDash includes Skills Files as part of its core, maintained and updated by the CMS team.
