Blog from Your IDE: Write and Publish Posts from Cursor or VS Code

Developers live in their code editors. Switching to a browser-based CMS to write a blog post breaks the flow — different app, different context, different mental model. What if publishing a blog post was the same as asking your AI assistant to refactor a function? Same editor, same conversation, same workflow.

With MCP (Model Context Protocol), Cursor and VS Code with AI extensions can connect directly to your blog. You write in the editor, ask the AI to draft or publish, and the post goes live without opening a browser. This guide covers the setup and practical workflows for developer-focused blogging from your IDE.

Diagram showing the IDE-to-blog publishing flow: developer types in Cursor, AI assistant calls MCP tools, blog post appears live on the web
IDE publishing: write code and blog posts in the same environment

Why blog from the editor

The argument is straightforward: developers already have a high-quality text editor open all day with AI assistance built in. Using it for blogging eliminates three friction points:

  • No context switch. Markdown or structured content in the editor. No switching to wp-admin, no waiting for dashboard pages to load, no re-authenticating in a browser.
  • AI is already there. Cursor has built-in AI. VS Code has Copilot. Both support MCP. The same assistant that helps you code can help you write, research, and publish.
  • Version control optional. You can treat blog drafts like code: write in a file, iterate, publish when ready. Or skip the file entirely and publish through a conversational MCP call.

This is not about replacing the dashboard. The dashboard works well for non-technical users . But for developers who want their blog in their terminal, MCP makes it possible.

Set up blog publishing in Cursor

Cursor supports MCP servers natively. The setup is a JSON configuration file.

1. Get your API key

Sign up at modernblogging.net and go to Dashboard → API Key. Generate a key (starts with mb_ ).

2. Add the MCP server

Open Cursor Settings → MCP Servers, or edit the MCP config directly:

json
{
  "mcpServers": {
    "modern-blogging": {
      "url": "https://modernblogging.net/api/mcp",
      "headers": {
        "Authorization": "Bearer mb_YOUR_API_KEY"
      }
    }
  }
}

3. Verify the connection

In the Cursor chat, type: "List my blogs using the modern-blogging MCP server." Cursor should call list_tenants and return your blog subdomain, URL, and plan.

💡

Cursor-specific: Cursor's Agent mode enables multi-step tool use. Ensure you are in Agent mode (not Ask mode) when you want Cursor to make MCP calls autonomously.

Set up blog publishing in VS Code

VS Code supports MCP through extensions like GitHub Copilot Chat (with MCP support) or third-party MCP clients. The configuration is similar:

  1. Install an MCP-compatible extension that supports remote MCP servers via HTTP.
  2. Add the MCP server URL : https://modernblogging.net/api/mcp with Bearer token authentication.
  3. Test with a list_tenants call to confirm the connection works.

The MCP protocol is standardized, so any client that supports it — Cursor, VS Code, Claude Desktop, Claude Code, Windsurf, or custom agents — works identically.

Five practical workflows

Workflow 1: Document your project

You just finished a feature. While the context is fresh, ask your IDE AI to blog about it:

text
"Write a blog post about implementing rate limiting 
with Cloudflare Workers KV. Use the code I just wrote 
as the technical reference. Target the keyword 
'rate limiting Cloudflare Workers'. Create as draft."

The AI reads your codebase (in Cursor) or the open file (in VS Code), generates a post with technical depth that matches your implementation, and publishes it as a draft. You review, adjust the tone, and publish.

Workflow 2: Write a tutorial series

Plan a multi-part series in the editor. Create a markdown file outlining the series, then ask the AI to generate each post:

text
"Create the next post in the series. Part 3 covers 
authentication. Link back to Part 1 (slug: auth-series-intro) 
and Part 2 (slug: auth-series-oauth). Use the focus keyword 
'API authentication tutorial'."

The AI uses create_post with internal links, sequential slugs, and consistent categories. Each post links to the others, building strong internal linking automatically.

Workflow 3: Research and write

Combine research_topic with create_post in a single conversation:

text
"Research 'headless CMS comparison 2026' and then write 
a post based on what competitors cover. Make sure we address 
any gaps in their coverage."

The AI fetches live search results, analyzes competitor content structure, drafts a comprehensive post that fills content gaps, and scores it against the 12-point SEO validator . All in one prompt.

Workflow 4: Quick updates

Fix a typo, add a paragraph, update a statistic:

text
"Update the post 'rate-limiting-cloudflare-workers' — 
change the benchmark from 10,000 to 15,000 requests/second 
in the performance section."

The AI calls update_post with the specific change. No need to open the dashboard, find the post, navigate to the right paragraph, and edit.

Workflow 5: Blog maintenance

Manage your blog structure without leaving the editor:

text
"Create a new category called 'Performance Engineering'. 
Move the rate limiting and caching posts into it. 
Update the site subtitle to 'Engineering at Scale'."

Three MCP calls: create_category , update_post (×2), update_settings . The AI handles category creation, post updates, and site configuration in one conversation.

MCP tools most useful from an IDE

Tool

What it does

IDE use case

create_post

Create a draft or published post

Write from editor context

update_post

Edit any field on an existing post

Quick fixes, content updates

publish_post

Publish a draft

Approve and ship

research_topic

Analyze SERP competitors

Data-driven writing

list_posts

List all posts with metadata

Find posts to update

generate_theme

Create theme from description

Style your blog from a prompt

upload_image

Upload image URL to CDN

Add cover images

export_data

Export all content as JSON

Backup, migration, analysis

The full 26-tool reference is in the MCP blog tool guide . All tools are available on the free plan.

IDE publishing vs other methods

Method

Context switch

AI assistance

Technical depth

Best for

IDE + MCP

None

Full (Cursor/Copilot)

High — reads codebase

Developer blogging

Claude Desktop

Minimal

Full (Claude)

Medium

Research-heavy posts

Dashboard editor

Full switch

None

Low

Visual editing, non-developers

REST API scripts

Minimal

None

High

Automated pipelines

IDE publishing is specifically better for developer bloggers because the AI assistant has access to your code, your project structure, and your recent work. That context produces more technically accurate posts than writing from scratch in a browser. For a Claude-first workflow , Claude Desktop is the better choice when you are not in a coding context.

Tips for effective IDE blogging

  • Write when context is fresh. The best developer blog posts come from problems you just solved. Blog from the IDE while the implementation details are still in your working memory.
  • Use your code as source material. In Cursor, the AI can read your project files. Reference specific implementations and let the AI incorporate technical details accurately.
  • Draft first, always. Create posts as drafts, review in the dashboard for visual layout, then publish via MCP when everything looks right.
  • Combine MCP servers. Your IDE can connect to multiple MCP servers simultaneously. Blog publishing, database access, deployment — all available in the same conversation.
  • Set up internal linking. Reference your existing posts by slug. The SEO benefits of internal linking compound as your blog grows.

Your editor is your CMS

The separation between "writing code" and "writing about code" is a tool problem, not a workflow problem. When your blog is accessible from the same environment where you build software, publishing becomes a natural extension of development.

Create a free blog , generate an MCP API key, and add two lines of JSON to your Cursor config. Your next blog post is an AI conversation away — in the same window where you write code.

Share this post
𝕏in
Built with Modern Blogging

This article was written, styled, and published using the Modern Blogging platform. Launch your own fast, SEO-ready publication in minutes.

Start for free →