What is the mcp-builder skill?
MCP Builder is a skill in Anthropic's anthropics/skills repository that gives an AI coding agent a four-phase process for writing Model Context Protocol servers: research the API and the MCP specification, implement tools in Python or TypeScript, review code quality, then write evaluation questions that verify the server works for real tasks.
The mcp-builder skill is part of Anthropic's public anthropics/skills repository, defined in SKILL.md with reference guides for Python and TypeScript implementation. Its stated job is a repeatable process for creating Model Context Protocol servers that let an agent call an external API through well designed tools.
It does not write a server from a one-line request. It is a four-phase guide: research the target API and the MCP specification, implement the tools, review the code, then write evaluation questions that check the server on real tasks.
What changes in the agent's output
- The agent studies the MCP specification and the target API before writing any tool, instead of guessing at a schema.
- Tool names get a consistent prefix and an action-oriented verb, such as github_create_issue or github_list_repos, so an agent calling the server can find the right one fast.
- Input schemas use Zod in TypeScript or Pydantic in Python, with constraints and examples in the field descriptions.
- Error messages name what went wrong and suggest a next step, rather than returning a bare status code.
- Each tool gets annotations such as readOnlyHint and destructiveHint so a calling agent knows what a tool is allowed to do before it runs it.
The four-phase process
Phase 1 is research and planning: read the MCP specification, pick TypeScript with streamable HTTP for a remote server or stdio for a local one, and list the API endpoints to cover. Phase 2 is implementation of the client, the tools and their schemas.
Phase 3 is review and test: a code-quality pass for duplication and error handling, then a build check and a run through the MCP Inspector. Phase 4 is ten evaluation questions, each independent, read-only and verifiable, written as an XML document of question and answer pairs.
Who the mcp-builder skill is for
Best for
- Turning an existing REST or GraphQL API into a set of tools an agent can call.
- Choosing between wide endpoint coverage and a few higher-level workflow tools for a given API.
- A first MCP server in Python or TypeScript, where the project layout and schema rules are not yet decided.
- Writing evaluation questions that prove a finished server holds up on realistic, multi-step requests.
Not for
- Editing an existing Penpot project directly is covered by Penpot MCP Server, which renames layers and drafts CSS from your canvas.
- Planning the visual design of a landing page from a brief is the job Frontend Design Skill handles before any server code exists.
- Reading design context straight out of an existing Figma project is the task Figma MCP Server handles, separate from writing new server tools.
- Running a WCAG accessibility audit on a finished page is handled by Web Accessibility Audit Skill, a separate four-phase process from building a server.
- Fetching shadcn/ui component source for a frontend build is covered by shadcn MCP Server, a different kind of tool server than this skill builds.
Use it with UiChemy
The skill builds the server that gives an agent new abilities, such as reading a design system or a CMS. Once that data is reachable, UiChemy Composer can use it while building or editing a WordPress page. Click Get Started on uichemy.com.
How to install MCP Builder Skill: Build an MCP Server
/plugin marketplace add anthropics/skillsAdd the marketplace
In Claude Code, run
/plugin marketplace add anthropics/skills. This registers the repository as a plugin marketplace named anthropic-agent-skills.Install the plugin that contains it
Run
/plugin install example-skills@anthropic-agent-skills. Mcp-builder ships inside the example-skills plugin, which bundles it with 11 other skills from the repo, including frontend-design and skill-creator.Ask for it by name
Mention the skill directly in a request, for example: use the mcp-builder skill to build an MCP server for the Stripe API.
On Claude.ai or the API
The README states the example skills are already available to paid Claude.ai plans, and that skills can also be used through the Claude API.
Check that it loaded
Open the plugin list and confirm example-skills is installed, then ask the agent to use the mcp-builder skill for a target API. It should start by reading the MCP specification and the API docs before it writes any tool code.
Key features
- Four-phase workflowResearch and plan, implement, review and test, then write evaluations. Each phase has its own checklist so a server is not shipped before it has been exercised by real questions.
- Coverage versus workflow toolsWeighs broad API endpoint coverage against a smaller set of specialized workflow tools, and defaults to wide coverage when the right balance is not obvious.
- Tool naming rulesConsistent prefixes and action-oriented verbs, such as github_create_issue, so an agent calling the server can find the right tool without reading every description.
- Context-aware responsesTool descriptions stay concise, and results support filtering and pagination so a calling agent is not handed more data than a task needs.
- Actionable error messagesErrors are written to guide the calling agent toward a fix, with a specific suggestion or next step instead of a bare failure code.
- Schema and annotation rulesInput schemas use Zod or Pydantic with constraints and examples. Tools carry readOnlyHint, destructiveHint, idempotentHint and openWorldHint so their effects are declared up front.
- Transport guidanceStreamable HTTP with stateless JSON for a remote server, stdio for a local one, picked for how each scales and how hard it is to maintain.
- Build and Inspector checksTypeScript servers run through a build step; Python servers get a syntax check. Both are then exercised with the MCP Inspector before the evaluation phase starts.
- Ten-question evaluation setPhase 4 asks for ten questions that are independent, read-only, realistic and have one verifiable answer, so the finished server is tested against real tasks, not just a smoke test.
- XML answer formatEvaluation questions and their verified answers are saved as qa_pair entries in one XML document, a format a grading script can check by string comparison.
Frequently asked questions
What is the mcp-builder skill?
It is a skill from Anthropic's anthropics/skills repository that gives an agent a four-phase process for writing Model Context Protocol servers: research the target API and the MCP specification, implement typed tools, review the code, then write ten evaluation questions that check the server on realistic tasks.
How do I install the mcp-builder skill?
Run /plugin marketplace add anthropics/skills, then /plugin install example-skills@anthropic-agent-skills. Mcp-builder is part of the example-skills plugin, so 11 other example skills install with it. After that, mention the skill in a request, for example: use mcp-builder to wrap the Notion API.
What does the mcp-builder skill actually build?
It builds a Model Context Protocol server: a small program exposing tools, each backed by a real API call, that a calling agent can use to read or act on an external service. The skill covers project setup, the tool schemas, error handling, pagination and a build and test pass.
Does the mcp-builder skill support Python as well as TypeScript?
Yes. SKILL.md gives a reference guide for each: Zod schemas and server.registerTool calls for TypeScript, Pydantic models and the @mcp.tool decorator for Python. It recommends TypeScript first for its SDK support and static typing, but both paths get full implementation and testing guidance.
What is a Model Context Protocol server?
An MCP server is a program that exposes a set of tools, each wrapping an API call, so an AI coding agent can read data from or act on an external service through a defined protocol rather than a one-off integration. The mcp-builder skill is a guide for writing one well.
How does the mcp-builder skill test the server it builds?
Phase 3 runs a code-quality pass for duplication and error handling, then a build check (TypeScript) or a syntax check (Python), followed by a run through the MCP Inspector. Phase 4 adds ten evaluation questions, each independent and verifiable, saved as question and answer pairs in an XML document.
Is the mcp-builder skill specific to one AI agent?
The repository README documents three routes for this skill: Claude Code, Claude.ai and the Claude API. The SKILL.md itself describes a general process for writing an MCP server, so the planning and schema rules carry over to any coding agent that can read a skill definition and call tools.