I've been enjoying sharing my (growing) collection of Claude Code workspace models.

These are - loosely defined - variations on a common line of thought:

• Claude Code / other agentic CLIs likes to work in a repo. It's safer to work with tools that can edit your filesystem when that's the case.
• A repo is basically a version-controlled chunk of a filesystem.
• A version-controlled folder can be used for literally anything from editing music to video. "Codebases" are just what we reflex to out of habit of thought and the fact that devs tend to think like ... well, devs.

Today's pattern is one that I've been enjoying using:

I use AI for a lot.

But when it comes to writing, my usage is quite cautious (for anyone wondering, I'm typing this by hand!). I write in my voice. I'm not a fan of AI writing tools that generate endless streams of mediocre "content" at the push of a button (or prompt).

However, I see huge value in using AI to:

• Act as a more intelligent proofreader than a stock correction tool
• Add subheadings. Even if they're not the best and I'll end up rewriting them, I find it has a knack for identifying logical breaks in the text
• Dropping images into markdown and writing relative paths. I bring no value to this task over a robot.

A few years ago I made the reluctant switch over from hosting Wordpress blogs to the vast and somewhat unwieldy jungle called headless CMS.

As a kind of weird writer-developer hybrid (I'm not the only one, right?) these pose great challenges to me:

• Writing in an IDE is awkward and not very scalable
• Headless CMS is great but complicated. The plurality of stack options is its own headache.

However, running conetent with an API opens up great possibilities in the era of AI and MCP.

We can:

• Chat with Claude (etc)
• Provide Claude with an MCP to a headless CMS (say, Contentful)
• Work on content wherever we like to work on it and then ask Claude to do the API finagling needed to push that to our frontend

This can be done with Wordpress (etc). But staying API + MCP centric makes this pattern feel more logical.

I've layed out a bare bones CLAUDE.md which can be overwritten.

Agentic AI systems thrive when:

• Parameters are tightly defined
• Tasks are modular

For that reason I recommend creating one workspace for each blog you manage. Even though you could drop in a few sets of the same MCP (with different credentials and labels), I didn't find that that pattern worked as well.

1. Initialize the workspace by running the slash command:

   /init-workspace
   

   This will guide you through setting up your blog details and update the CLAUDE.md configuration.

2. Configure your MCP: Make sure you have the appropriate MCP server configured for your blog platform (e.g., Contentful, WordPress)

3. Start drafting: Create your content in the /drafting/ directory

4. Publish with Claude: Ask Claude to proofread, edit, and publish your content using the configured MCP

.
├── .claude/
│   └── commands/
│       └── init-workspace.md    # Workspace initialization command
├── drafting/                     # Work on drafts here
├── published/                    # Archive of published posts
├── CLAUDE.md                     # AI assistant configuration
└── README.md                     # This file

1. Create a new draft: drafting/my-new-post.md
2. Ask Claude to proofread and suggest improvements
3. Request publication: "Please publish this post to my blog"
4. Claude uses the MCP to publish and archives to published/

This is a Claude Code workspace pattern. To view an index of my Claude Code related projects, click here.