Anthropic★ 4.3

MCP Builder

Anthropic's official Skill for scaffolding new MCP servers. Sets up the project, generates tools, validates the schema.

View repo Homepage

A+

Safety & Trust

Delv Safety Grade: A+

Score 93/100 · assessed 2026-04-18

Maintainer95

Permissions88

Supply chain95

Transparency92

Incidents100

MCP Builder is Anthropic's official Skill for scaffolding Model Context Protocol servers, distributed through their verified skills repository. As a first-party tool from the company that created both Claude and the MCP specification, it carries maximum maintainer trust. The Skill generates TypeScript code and project structure, requiring filesystem write access to create new directories and files. Permissions are appropriately scoped to code generation tasks: writing project files, reading existing schemas for validation, and executing shell commands for dependency installation. Supply chain is clean, distributed via GitHub with clear versioning and standard npm dependencies. Transparency is excellent with full source visibility, comprehensive documentation, and active maintenance. No security incidents recorded. The primary risk surface is filesystem write and shell execution for npm install, but this is inherent to any scaffolding tool and appropriately scoped to project directories rather than system-wide access.

Green flags

Official Anthropic Skill, first-party maintainer with direct MCP ownership
Open source with full visibility into code generation logic
Validates generated schemas against official MCP specification
Active maintenance in primary Anthropic skills repository
Scoped to project directories, not system-wide filesystem access

Red flags

Requires filesystem write access to generate project structure
Executes shell commands for npm/dependency installation
Generated code quality depends on prompt clarity and validation

Permissions requested

Write filesRead filesShell executeOutbound network

Assessed by Delv Editorial using public metadata. Grades are advisory and update as the ecosystem changes. They do not replace your own review of permissions and code before granting an agent access to sensitive systems.

MCP Builder is Anthropic's official Skill for generating Model Context Protocol servers. It handles the scaffolding work that Claude often gets wrong when working from memory alone: setting up project structure, defining tools with compliant JSON schemas, generating SDK boilerplate, and validating against the MCP spec. The Skill walks through tool definitions, parameter schemas, and resource handlers, catching common mistakes like optional parameter mishandling or malformed JSON-RPC stubs. It's opinionated about TypeScript and the official MCP SDK, so Python developers or teams with custom transport layers will need to adapt the output. Runtime behaviour and API integration are still your job, but for getting a working, spec-compliant server running in minutes rather than hours, this is the canonical path.

Review

I've watched Claude fumble MCP server scaffolding for months. It knows the spec, sure, but ask it to spin up a new server and you'd get half-baked TypeScript, misaligned schemas, and tools that failed validation. MCP Builder fixes that. It's Anthropic's official Skill for generating MCP servers from scratch or extending existing ones, and it actually understands the schema nuances that matter. The workflow is straightforward: describe the server you want, and Claude walks through tool definitions, parameter schemas, and SDK boilerplate. I tested it against a manual setup for a Notion integration. Without the Skill, Claude gave me a server.ts with tools that looked plausible but failed the MCP validator on optional parameter handling. With MCP Builder loaded, it caught the schema mismatch immediately and generated compliant JSON-RPC stubs. The real win is speed. Bootstrapping a new server that actually works takes minutes, not an hour of back-and-forth debugging. It handles the tedious bits: setting up the project structure, wiring in the MCP SDK, validating tool schemas against the spec. For adding tools to an existing server, it respects your current architecture instead of rewriting everything. Rough edges: it's opinionated about TypeScript and the official SDK. If you're building in Python or rolling your own transport layer, you'll need to adapt the output. The Skill also assumes you understand MCP basics; it won't teach you what a resource is or why you'd use prompts over tools. And while it validates schemas, it doesn't test runtime behaviour. You still need to wire up actual API calls and handle errors yourself. But for the common case, getting a spec-compliant server running quickly, this is the fastest path. I'd reach for it every time I'm prototyping a new integration or onboarding someone to MCP development.

Verdict

Load this if you're building MCP servers regularly or teaching someone the ropes. Skip it if you're maintaining a mature server in a non-TypeScript stack or prefer total control over scaffolding.

Good at

Generates spec-compliant MCP servers that pass validation first time
Catches schema mistakes Claude typically makes when working from memory
Handles tedious boilerplate: project setup, SDK wiring, JSON-RPC stubs
Works for both new servers and extending existing ones
Significantly faster than manual scaffolding and debugging

Watch out

Opinionated about TypeScript and the official SDK, less useful for Python or custom stacks
Assumes you already understand MCP concepts, not a teaching tool
Validates schemas but doesn't test runtime behaviour or API integration
Output may need adaptation if you have strong architectural preferences
Overkill if you're only maintaining an existing, stable server

Use cases

Bootstrapping a new MCP server in minutes
Adding tools to an existing server with the right schema
Generating SDK boilerplate for a new integration
Validating an MCP server against the spec