Mother MCP Skills

The npm for AI agent skills. A Model Context Protocol (MCP) server that automatically provisions the right skills for your project — across Claude Code, GitHub Copilot, OpenAI Codex, and Vercel v0.

Just like npm discovers and installs the packages you need, Mother MCP discovers and installs the AI skills your project needs.

How It Works

Mother MCP is a consumer of the agent_skills_directory — the central catalog of AI skills from providers like Anthropic, OpenAI, GitHub, Vercel, and the community.

┌─────────────────────────────────────────────────────────────────┐
│                   agent_skills_directory                        │
│  The canonical source of AI skills (112+ skills, 6 providers)   │
│  • GitHub stars, downloads, verification status                 │
│  • Skill metadata, provider info, compatibility                 │
└────────────────────────────┬────────────────────────────────────┘
                             │ fetches catalog
                             ▼
┌─────────────────────────────────────────────────────────────────┐
│                        Mother MCP                               │
│  Consumer & Reporter - detects your stack, installs skills      │
│  • Reads quality signals from registry (not generates them)     │
│  • Downloads skills to .github/skills, .claude/skills, etc.     │
└─────────────────────────────────────────────────────────────────┘

Mother MCP does NOT:

• Generate download counts or star ratings

• Host or maintain the skill registry

• Track usage analytics

Mother MCP DOES:

• Consume the catalog and display skill metadata

• Match skills to your detected tech stack

• Install skills to the right location for your AI agent

Demo

Coming Soon: Interactive demo showing automatic skill detection and installation in seconds.

Resources

📄 Full Documentation — Complete setup guide and feature walkthrough
📊 Visual Overview (PDF) — One-page infographic explaining the architecture
🎬 Video Demo — Coming soon

Supported Agents

Why Reusable Skills Matter

"If you'll do roughly the same thing 10+ times, encode it as a reusable skill. Under 3 times? Just tell Sonnet."

The Problem with "Just Ask the AI"

You can ask Claude to help with any task ad-hoc. But for teams and repeated workflows, this approach breaks down:

Where Skills Add Real Value

✅ High-value (use skills)

• Repeated SDLC steps: PR reviews, security checks, test generation, docs

• Org-specific knowledge: architecture rules, domain models, compliance

• Cross-project utilities: dependency upgrades, migrations, repo analysis

❌ Low-value (just prompt)

• Quick throwaway scripts or spikes

• Highly unique one-off tasks

The Before/After

Without Mother (prompt tax every time):

Hey Claude, review this PR for security issues. Check for SQL injection, 
XSS, also we use React so watch for dangerouslySetInnerHTML, and our 
team prefers early returns, and don't forget we have a custom auth 
middleware pattern, and...

With Mother (skill already knows your stack):

/review

The skill knows your framework, your patterns, your team's standards — because it was installed based on your actual project context.

What It Does

Mother MCP automatically:

1. Detects your project's tech stack using a 3-tier strategy:

   • GitHub SBOM API for accurate dependency data (340+ packages)

   • Specfy analyser for 700+ technologies including infrastructure & SaaS

   • Local scanning as offline fallback

2. Matches detected technologies to available skills from trusted registries

3. Downloads relevant skills to the appropriate location (.github/skills, .claude/skills, or .codex/skills)

4. Adapts to whichever AI agent you're using (Claude, Copilot, or Codex)

Installation

Claude Code Plugin (Easiest)

Install via Claude Code's plugin marketplace:

# Add the marketplace
/plugin marketplace add dmgrok/mcp_mother_skills

# Install the plugin
/plugin install mother-mcp@mother-mcp-marketplace

Or install directly from GitHub:

/plugin install dmgrok/mcp_mother_skills

Once installed, the Mother MCP server will be available in Claude Code.

Quick Install via npm

# Install globally
npm install -g mcp-mother-skills

# Or use with npx (no install needed)
npx mcp-mother-skills

From Source

# Clone the repository
git clone https://github.com/dmgrok/mcp-mother-skills.git
cd mcp-mother-skills

# Install dependencies
npm install

# Build
npm run build

Configuration

Claude Code

Add to your project's .mcp.json or global config:

{
  "mcpServers": {
    "mother-skills": {
      "command": "npx",
      "args": ["mcp-mother-skills"],
      "env": {
        "MOTHER_PROJECT_PATH": "."
      }
    }
  }
}

Or if installed globally:

{
  "mcpServers": {
    "mother-skills": {
      "command": "mcp-mother-skills",
      "env": {
        "MOTHER_PROJECT_PATH": "."
      }
    }
  }
}

Claude Desktop

Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "mother-skills": {
      "command": "npx",
      "args": ["mcp-mother-skills"],
      "env": {
        "MOTHER_PROJECT_PATH": "/path/to/your/project"
      }
    }
  }
}

Or if installed globally:

{
  "mcpServers": {
    "mother-skills": {
      "command": "mcp-mother-skills",
      "env": {
        "MOTHER_PROJECT_PATH": "/path/to/your/project"
      }
    }
  }
}

VS Code with Copilot

Add to your VS Code settings or .vscode/mcp.json:

{
  "mcp.servers": {
    "mother-skills": {
      "command": "npx",
      "args": ["mcp-mother-skills"],
      "env": {
        "MOTHER_PROJECT_PATH": "${workspaceFolder}"
      }
    }
  }
}

Or if installed globally:

{
  "mcp.servers": {
    "mother-skills": {
      "command": "mcp-mother-skills",
      "env": {
        "MOTHER_PROJECT_PATH": "${workspaceFolder}"
      }
    }
  }
}

Usage

Setup (First-Time Onboarding)

When first using Mother MCP, call setup to get started:

Setup my Mother MCP

This will:

• Scan your project to detect technologies (languages, frameworks, databases, tools)

• Fetch the skill registry and find matching skills

• Show recommended skills with match explanations

• Let you choose which skills to install

Sync Skills (Ongoing Updates)

Call sync_skills at the start of each conversation:

Use sync_skills to ensure I have the right skills for this project

This will:

• Detect your project's technologies

• Download matching skills from the registry

• Report what was added/updated/removed

Reset Skills (Start Fresh)

If you need to start over or troubleshoot issues, use reset_skills:

Reset all my Mother MCP skills with confirm=true

Important: You must set confirm=true to proceed with the reset.

Options:

• confirm (required): Set to true to confirm the reset action

• all_agents: Remove skills for all agents (Claude, Copilot, Codex), not just the detected one

• clear_config: Also remove Mother configuration files (.mcp/mother/)

• clear_cache: Clear the skill registry cache

Examples:

# Reset only the current agent's skills
reset_skills with confirm=true

# Reset all agents and clear config
reset_skills with confirm=true, all_agents=true, clear_config=true

# Full reset including cache
reset_skills with confirm=true, all_agents=true, clear_config=true, clear_cache=true

This will permanently delete all installed skills. After resetting, run setup to reinstall skills.

Other Commands

Skill Bundles

Bundles are curated collections of skills for common development use cases. Instead of installing skills one by one, get a complete stack with one command:

> list_bundles

📦 Available Bundles:
⚛️  frontend-react      - Modern React development with TypeScript and testing
🚀 fullstack-nextjs    - Complete Next.js stack with database and deployment
🐍 api-python          - FastAPI with async patterns and PostgreSQL
🐳 devops-docker       - Containerization with GitHub Actions deployment
🧪 testing-frontend    - Unit, integration, and E2E testing for web apps

> install_bundle fullstack-nextjs

🚀 Full-Stack Next.js: 7 installed, 0 already present
   ✅ nextjs, react, typescript, prisma, postgresql, docker, github-actions

Project Configuration

Mother MCP creates a .mcp/mother/ directory in your project:

.mcp/mother/
├── config.yaml           # Mother configuration
├── project-context.yaml  # Detected context (auto-generated)
└── cache/               # Registry cache

config.yaml

version: "1.0"

agent:
  mode: auto          # auto, claude, copilot, codex
  sync_both: false    # Install to both .github/skills and .claude/skills

registry:
  - url: "https://cdn.jsdelivr.net/gh/dmgrok/agent_skills_directory@main/catalog.json"
    priority: 1

cache:
  refresh_interval_days: 7

skills:
  always_include: []  # Skills to always install
  always_exclude: []  # Skills to never install

sync:
  auto_remove: false  # Remove skills when no longer detected

Skills Registry

Mother MCP fetches skills from the Agent Skills Directory, an automatically updated catalog aggregating skills from multiple providers:

Total: 112 skills across documents, creative, development, data, enterprise, integrations, and other categories.

Bring Your Own Registry

Want skills tailored for your organization? The registry URL is fully configurable. Just point to your own catalog:

# .mcp/mother/config.yaml
registry:
  # Use your company's private registry
  - url: "https://skills.yourcompany.com/catalog.json"
    priority: 1
  
  # Optionally keep the public registry as fallback
  - url: "https://cdn.jsdelivr.net/gh/dmgrok/agent_skills_directory@main/catalog.json"
    priority: 2

This lets you:

• Curate skills for your organization's specific tech stack and standards

• Add proprietary skills that encode internal knowledge and patterns

• Control what skills are available to your engineering teams

• Version and audit skills through your own infrastructure

Your private registry just needs to serve a JSON catalog in the same format as the public catalog.

Registry Catalog Format

The registry catalog supports community quality signals - metadata that helps users discover and trust skills:

skills:
  - name: react
    path: skills/react
    version: "1.5.0"
    description: "React patterns, hooks, and component architecture"
    triggers:
      packages: ["react", "react-dom"]
    tags: [framework, frontend]
    
    # Community Quality Signals (all optional)
    downloads: 28500           # Install count
    stars: 523                 # GitHub stars
    verified: true             # Publisher verified badge
    publisher:
      name: "Mother Skills Team"
      url: "https://github.com/mother-mcp"
      verified: true
    compatibility:             # Agent compatibility matrix
      claude: true
      copilot: true
      codex: true
      v0: true
    repository: "https://github.com/mother-mcp/skills"

These signals are displayed in search results and recommendations to help users choose quality skills.

Available Skills

Documents & Data: pdf, docx, pptx, xlsx, doc-coauthoring

Creative & Design: frontend-design, canvas-design, theme-factory, brand-guidelines, algorithmic-art, web-artifacts-builder

Development: mcp-builder, skill-creator, webapp-testing, internal-comms, create-plan, gh-fix-ci, gh-address-comments

Enterprise: linear, slack-gif-creator, notion-spec-to-implementation, notion-meeting-intelligence, notion-knowledge-capture, notion-research-documentation

Infrastructure: azure-role-selector, snowflake-semanticview

The catalog is refreshed automatically. See catalog.json for the full list.

How Skills Are Matched

Mother MCP uses a tiered detection strategy for comprehensive tech stack analysis:

Tier 1: GitHub SBOM API (Most Accurate)

When connected to a GitHub repository, Mother fetches the Software Bill of Materials directly from GitHub's dependency graph:

• Automatic repo detection from local .git/config remote URL

• Parses SPDX-formatted dependency data with 340+ packages

• PURL parsing for ecosystem detection (npm, pip, cargo, maven, etc.)

• Requires GITHUB_TOKEN environment variable

Tier 2: Specfy Stack Analyser

Comprehensive detection of 700+ technologies:

• Languages, frameworks, databases, infrastructure

• SaaS tools, cloud services, CI/CD systems

• Works offline with local file analysis

Tier 3: Local Detection (Fallback)

Traditional file scanning for offline environments:

Git Remote Auto-Detection

Mother automatically detects your GitHub repository from local git configuration:

# Supported URL formats:
git@github.com:owner/repo.git      # SSH
https://github.com/owner/repo.git  # HTTPS
ssh://git@github.com/owner/repo    # SSH URL

Skill Locations

Skills are installed based on detected agent:

Agent Detection

Mother MCP auto-detects which agent is using it through multiple methods:

Note: Codex skills follow the Open Agent Skills Standard specification.

Architecture: Static Instructions vs Dynamic Skills

Mother MCP separates concerns between static project documentation and dynamic skill provisioning:

Key principle: Mother MCP never modifies your instruction files. It only manages:

• Its own config in .mcp/mother/

• Skill files in the appropriate skills directory

Recommended Workflow

Add this to your project's CLAUDE.md or .github/copilot-instructions.md:

## Startup

At the start of each conversation, call `sync_skills` to ensure project-relevant skills are loaded.

This connects your static instructions to Mother's dynamic skill system.

Development

# Run in development mode
npm run dev

# Build
npm run build

# Watch mode
npm run watch

Community & Roadmap

Mother MCP is evolving into a community-driven skill ecosystem — the npm for AI skills. Here's what we're building:

Quality Signals (Coming Soon)

Contribution Tools (Coming Soon)

How You Can Help

1. Star skills you find useful — helps surface quality

2. Report issues with skills that have outdated advice

3. Contribute skills via PR to agent_skills_directory

4. Share your use cases — what skills would help your workflow?

Join the discussion: GitHub Issues

License

MIT