mcp2skill — Summary

A production-quality Go CLI tool that converts MCP server configurations into agent skill packages following the agentskills.io specification. The tool introspects live MCP servers (stdio and HTTP transports), generates SKILL.md and TOOLS.md reference files, and embeds the binary itself into the generated skill for self-contained distribution.

mcp2skill is the mature, cross-platform successor to the proof-of-concept mcp-to-skill-converter (also in this batch). It supports both stdio and HTTP MCP transports, OAuth flows for HTTP servers, project-level config cascading, skill update detection (update-skill command), and optional binary embedding. The generated skill packages target Claude Code, OpenCode, Codex, Gemini CLI, and Qwen Code.

With 51 stars and a v1.x release track (GitHub Releases), this is the most production-ready MCP-to-skill converter in the ecosystem. The go install path is github.com/fenwei-dev/mcp2skill/cmd/mcp2skill@latest. Compared to seeds: closest to taskmaster-ai (CLI tool that generates structured artifacts) but purpose is conversion/wrapping rather than task management. It represents the "MCP-to-skill conversion" pattern at production quality versus the Python prototype's proof-of-concept quality.

mcp2skill — Overview

Origin

Created by fenwei-dev (GitHub), published January 2026. A production CLI tool with versioned releases, CI badges, and a demo video on YouTube. The README positions it as conforming to the agentskills.io specification and targeting multiple AI coding agents.

Philosophy

The tool's philosophy: MCP servers are a great tool definition format, but the skill format is a better runtime format for context-aware AI agents. Converting at build time (when setting up a new server) rather than at runtime (on every session start) preserves the MCP ecosystem's tool richness while gaining skill's progressive disclosure benefits.

Supported Targets (from README)

Generated skills are tested/documented for:

• Claude Code
• OpenCode
• Codex (OpenAI)
• Gemini CLI
• Qwen Code (Alibaba)

This is the broadest target coverage of any MCP-to-skill converter.

Transport Support

• stdio: Local MCP servers (Docker, npx, uvx)
• HTTP: Remote MCP servers with URL + headers
• OAuth: GitHub Copilot MCP (automatic token exchange)

Config Cascading

The tool looks for ~/.mcp2skill/config.json (global) and .mcp2skill/config.json in current/parent directories (project). Project config overrides global.

Versioning

Tagged releases available on GitHub. Latest version determined from GitHub Releases page. The install script (install.sh) uses the latest release.

mcp2skill — Architecture

Distribution

cli-tool — Go binary distributed via GitHub Releases, go install, or install script.

Install

# Quick install (Linux/macOS)
curl -sSL https://raw.githubusercontent.com/fenwei-dev/mcp2skill/main/install.sh | bash

# From Go module
go install github.com/fenwei-dev/mcp2skill/cmd/mcp2skill@latest

# Windows: download binary from GitHub Releases

Directory Tree (source)

mcp2skill/
├── cmd/
│   └── mcp2skill/         # Main CLI entry point
├── internal/
│   ├── cliapp/            # CLI command implementations
│   ├── config/            # Configuration management (global + project cascading)
│   ├── mcp/               # MCP client wrapper (stdio + HTTP + OAuth)
│   └── skill/             # Skill generation logic
├── go.mod
└── README.md

Generated Skill Structure (per server)

<output-dir>/
├── SKILL.md              # Main skill doc with agentskills.io frontmatter
├── references/
│   ├── TOOLS.md          # Generated tool reference
│   └── RESOURCES.md      # Generated resource reference (if applicable)
└── bin/
    └── mcp2skill         # Embedded binary (optional, for self-contained distribution)

Config File Format

{
  "mcp": {
    "fetch": {
      "type": "stdio",
      "command": "uvx",
      "args": ["mcp-server-fetch"],
      "env": {"API_KEY": "..."}
    },
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {"Authorization": "Bearer {github_pat}"}
    }
  }
}

Config Locations (cascade order)

1. --config flag (explicit)
2. .mcp2skill/config.json in current or parent directories (project)
3. ~/.mcp2skill/config.json (global)

Required Runtime

• Go >= 1.21 (for build from source)
• Pre-built binary: none

mcp2skill — Components

CLI Commands (3)

CLI Flags

Generated Output Files (2-4 per server)

Generated SKILL.md Frontmatter (agentskills.io standard)

---
name: my-server
description: Provides access to My MCP Server (v1.0.0) MCP server with tools: tool1, tool2.
  Use when the user requests My MCP Server functionality.
---

Skills (0 native)

The tool ships no skills of its own. It generates skills for other servers.

Hooks (0)

None.

MCP Servers (0)

mcp2skill is a converter, not a server itself.

Scripts (1)

mcp2skill — Uniqueness

differs_from_seeds

No direct seed analog. The closest is taskmaster-ai (CLI tool that reads config and generates structured artifacts), but taskmaster-ai generates task management artifacts while mcp2skill generates skill package artifacts. ccmemory is the conceptual inverse (builds an MCP server that wraps skill-like functionality). Unlike all 11 seeds, mcp2skill exists specifically in the MCP-to-skill conversion space — its value is the bridge between two ecosystem conventions.

Positioning

mcp2skill is the production counterpart to the Python mcp-to-skill-converter prototype in this batch. Key improvements: real MCP introspection (not mocked), Go binary for cross-platform distribution, OAuth support, update detection, agentskills.io specification conformance, embedded binary mode for self-contained skills.

Distinctive Opinion

By targeting agentskills.io (an open specification) rather than a single agent's format, mcp2skill positions itself as ecosystem infrastructure — not tied to any particular AI vendor.

Observable Failure Modes

1. MCP server startup failure: The converter must start the MCP server process to introspect it — if the server requires special auth or infrastructure, conversion fails
2. Schema complexity: Very complex MCP tool schemas may generate unwieldy TOOLS.md files
3. Version mismatch: If the MCP server updates its tools but the skill isn't updated, agents use stale documentation
4. OAuth complexity: GitHub Copilot MCP OAuth works but requires a valid GitHub PAT in the config
5. Embedded binary size: Adding bin/mcp2skill to every generated skill inflates skill package size

Relationship to mcp-to-skill-converter

Both frameworks implement the same concept (MCP → skill conversion). Key differences:

• mcp-to-skill-converter (Python): proof of concept, mocked introspection
• mcp2skill (Go): production quality, real introspection, OAuth, update detection, agentskills.io compliance, cross-platform binary

What Makes It Novel vs. the 11 Seeds

• Only framework implementing the agentskills.io open specification
• Only converter with real MCP server introspection (not just schema reading)
• Only framework targeting 5+ AI coding agents in its generated output
• Only framework with skill update detection to handle MCP server evolution