aiGalen Guan

MCP Builder Skill Review — The Missing Scaffolding Tool for AI Agent Tool Development

MCP Builder tool lifecycle automation — from scaffolding to full CI/CD

"MCP Builder" is one of those terms that everyone in the AI agent space seems to know about but nobody can point to. Ask a developer what it is, and you'll get three different answers: "The Anthropic scaffolding tool," "The npm create-mcp-server package," or "I thought that was just the MCP SDK."

It turns out all three answers are wrong — or more precisely, incomplete. The MCP Builder ecosystem is still in its infancy, and figuring out what's actually useful requires looking under the hood of each candidate.

What We Found

Searching GitHub for "mcp builder" reveals a fragmented landscape. The top results:

Project Stars What It Actually Is
modelcontextprotocol/create-python-server 478 Official Anthropic Python scaffolding template
salacoste/mcp-n8n-workflow-builder 225 n8n workflow management via MCP (specific integration, not a general builder)
npm create-mcp-server ~50 (npm) Basic TypeScript scaffolding, v0.0.1, no GitHub repo linked
hanweg/mcp-tool-builder 25 MCP server that creates its own tools dynamically

This is a strikingly thin ecosystem for a protocol that's become the standard for AI agent tool integration. The official Anthropic tool is the only meaningful candidate, and even it is less of a "builder" and more of a "template generator."

Anthropic's create-python-server — The De Facto Standard

Located at modelcontextprotocol/create-python-server (478 stars), this is an interactive CLI that scaffolds a Python MCP server. Run uvx create-python-server, answer a few prompts (project name, description, tool names), and you get a fully functional MCP server with:

  • A server.py entry point with stdio transport
  • A pyproject.toml with MCP SDK dependency and entry points
  • A README.md with setup instructions
  • A basic tool example (one tool, one parameter)

The generated code is clean and minimal — about 60 lines of Python that you can immediately extend. The scaffolding takes about 30 seconds from start to running server.

What it does well: Speed. You go from zero to a working MCP server faster than you can write the import statements yourself. The generated code follows MCP best practices (async handlers, proper tool registration, stdio transport), so newcomers don't have to learn the protocol to get started.

What it doesn't do: Everything else. It scaffolds a skeleton, not a production server. There's no testing template, no error handling patterns, no logging setup, no Docker configuration, no deployment guidance. It's a create-react-app for MCP — great for getting started, but you're on your own after the first 60 lines.

npm create-mcp-server — The Ghost

The npm package create-mcp-server exists at version 0.0.1. It has no linked GitHub repository, no documentation, and no meaningful description beyond "Create an MCP server with one command." Installing and running it produces a basic TypeScript project with MCP SDK — similar to the Python version but with even less polish.

It exists. That's about all you can say about it.

What the Ecosystem Is Actually Missing

The real gap isn't scaffolding — it's incremental tool development. Once you have your skeleton MCP server, adding a new tool involves:

  1. Write the tool function (easy)
  2. Register it in the server's tool list (easy)
  3. Write tests (medium)
  4. Add error handling (medium)
  5. Document the tool parameters (easy to forget)
  6. Update the README with examples (always forgotten)

Steps 3-6 are where MCP servers accumulate technical debt. A real MCP Builder would handle these automatically — add a tool, and the scaffolding generates the test template, error handler wrapper, and documentation stub.

Why This Matters for Hermes

Hermes is both an MCP client and (potentially) an MCP tool publisher. Our existing MCP integrations work through native MCP tools, and we have the Chrome CDP MCP server for browser automation. But every new tool we add requires the same manual wiring.

An MCP Builder skill for Hermes wouldn't just scaffold new servers — it would:

  1. Generate Hermes-native tool wrappers that bridge MCP tools into Hermes's tool system
  2. Auto-document tool parameters, return types, and error modes
  3. Generate integration tests using our webapp-testing skill patterns
  4. Maintain changelogs when tools are added or modified

This is a different problem than what Anthropic's create-python-server solves. Their tool helps humans create new MCP servers. A Hermes MCP Builder would help the agent create, document, and test its own tools.

Implementation Sketch

The minimal viable Hermes MCP Builder skill:

Hermes MCP Builder
├── Tool scaffolding     — Write tool function → auto-register → generate test template
├── Documentation gen    — Extract parameter types → generate Markdown docs
├── Test harness         — Connect to webapp-testing skill for integration tests
└── Registry update      — Update skill manifest when tools change

The core insight: treat MCP tool creation the way we treat code generation — with an automated quality loop. When the agent writes a new tool, the builder:

  1. Validates the implementation against the MCP spec
  2. Generates a test that calls the tool with valid and invalid inputs
  3. Runs the test
  4. If it passes, documents the tool and registers it

This turns tool creation from a manual process into a self-verifying workflow.

What to Adopt

Adopt: Anthropic's create-python-server as the scaffolding foundation for new Python MCP servers. It's clean, well-structured, and the official standard.

Build on top: A Hermes MCP Builder skill that adds: auto-test generation, parameter documentation extraction, changelog management, and Hermes-native tool registration. This is the layer the ecosystem doesn't have yet.

Skip: npm create-mcp-server (too immature), mcp-n8n-workflow-builder (too specific), hanweg/mcp-tool-builder (too experimental).

Verdict

Don't install an external MCP Builder — build one. The scaffolding tools exist but are insufficient for Hermes's needs. A proper MCP Builder skill that automates the full tool lifecycle (create → test → document → register) is a higher-leverage investment than adopting any existing tool.

Start with a skill that wraps Anthropic's create-python-server and adds: test generation, doc extraction, and Hermes tool registration. Ship it as a Hermes skill, not an external dependency.