MCP Maker: build a remote MCP server from your codebase

Every team using AI agents eventually hits the same wall: the agent needs to touch your internal systems — your database, your admin API, your billing scripts — and the Model Context Protocol is how you hand it those tools safely. The question everyone searches for is how to build a custom MCP server without spending a week on it. MCP Maker answers it with an agent skill: point a coding agent at your existing codebase and it designs, builds, tests, and deploys a remote MCP server for you. In this guide we set up MCP Maker, hand the actual coding to a tellnova background agent, and connect the finished server to Claude and any other MCP client.

What MCP Maker actually does

MCP Maker is not another boilerplate scaffolder. It is an agent skill — a set of instructions a coding agent follows — for "turning an existing codebase into a deliberately small, secure, tested remote Model Context Protocol server, or hardening one that already exists." It ships under MIT on GitHub, and the design choices are opinionated in the right places:

• The agent inspects your repository first and consults the current official MCP SDK documentation, instead of pattern-matching from stale training data.
• Tools are designed from user jobs, not mechanically mirrored from your API routes — a smaller, more useful surface than one-tool-per-endpoint generators produce.
• The result speaks Streamable HTTP, the current remote MCP transport, and gets deployed behind HTTPS with a verified connection URL handed back at the end.
• Security controls sit at real trust boundaries, and the server ships with contract, handler, transport, and operations checks — tested, not just generated.

Set up MCP Maker

Installation is a clone into your agent's skills directory. For Claude Code:

git clone https://github.com/MannJadwani/mcp-maker.git ~/.claude/skills/mcp-maker

For Codex, the same repo goes to ~/.agents/skills/mcp-maker. Both also work per-repository — .claude/skills/mcp-maker or .agents/skills/mcp-maker inside the project — which is the variant we want, because a background agent can do that step itself.

Once installed, you invoke it with /mcp-maker in Claude Code or $mcp-maker in Codex, or simply describe the task and let the agent pick the skill up.

Let a tellnova background agent do the coding

Building an MCP server is exactly the kind of task you should not babysit: it touches many files, runs tests repeatedly, and takes a while. tellnova runs coding agents in the background, each task in its own isolated git worktree, so the build happens on a branch while your checkout stays untouched. If you have not set it up yet, the short version: install from tellnova.com/#download, sign in with GitHub, connect a model provider, pick your repository.

Then fire the task in the composer:

Clone https://github.com/MannJadwani/mcp-maker.git into
.claude/skills/mcp-maker, then follow that skill to turn this
codebase into a remote MCP server. Design the tools around what
users actually do with this project, run the full verification
pass, and deploy it.

The agent installs the skill, reads your codebase, and works through the whole pipeline — tool contracts, handlers, security review, Streamable HTTP transport, deployment — while you do something else. When it finishes you review one diff: the server code, its tests, and the deployment config, all on an isolated branch. Shipping it is one click; tellnova opens the pull request. If the agent needs current MCP SDK docs mid-task, the Agent Reach skill gives it live web access.

Connect your MCP server to Claude — and everywhere else

MCP Maker's final output is a verified HTTPS connection URL. That URL is the whole integration story, because every serious AI tool now speaks MCP.

For Claude Code, one command:

claude mcp add --transport http my-server https://your-server.example.com/mcp

For Claude Desktop and claude.ai, add the same URL as a custom connector in Settings. Cursor, Codex, and other MCP clients take the same endpoint — write once, connect everywhere is the actual promise of the protocol, and the official MCP documentation lists the growing client ecosystem. tellnova's own transcripts render MCP tool calls, so agents in your next background task can use the very server a background task just built.

The loop that compounds

Notice the shape of what happened. A background agent installed a skill, used that skill to make your software reachable by agents, and the output plugs back into every agent you run. It is the same compounding pattern as making desktop software agent-native with CLI-Anything: each capability you add through an agent makes the next agent task stronger.

Your codebase probably has three or four internal jobs — look up a customer, requeue a failed import, pull usage numbers — that would be genuinely useful as MCP tools this week. Grab tellnova from tellnova.com/#download, point a background agent at MCP Maker, and review the finished server instead of writing it.