bad-example-skill

Name: bad-example-skill
Rating: 5 (8 reviews)
Author: bobmatnyc

by @bobmatnyc in AI & LLM

# Install this skill:

npx skills add bobmatnyc/claude-mpm-skills

Or install specific skill: npx add-skill https://github.com/bobmatnyc/claude-mpm-skills/tree/main/examples/bad-interdependent-skill

# Description

ANTI-PATTERN - Example showing violations of self-containment (DO NOT COPY)

# SKILL.md

name: bad-example-skill
description: ANTI-PATTERN - Example showing violations of self-containment (DO NOT COPY)
category: framework
toolchain: python
tags: [anti-pattern, bad-example, violations]
version: 1.0.0
author: claude-mpm-skills
updated: 2025-11-30
progressive_disclosure:
entry_point:
summary: "ANTI-PATTERN - Example showing violations of self-containment (DO NOT COPY)"
when_to_use: "When working with bad-example-skill or related functionality."
quick_start: "1. Review the core concepts below. 2. Apply patterns to your use case. 3. Follow best practices for implementation."

⚠️ BAD EXAMPLE - Interdependent Skill (Anti-Pattern)

WARNING: This is an ANTI-PATTERN example showing what NOT to do.

DO NOT COPY THIS STRUCTURE. See good-self-contained-skill for correct approach.

❌ VIOLATION #1: Relative Path Dependencies

## Related Documentation

For setup instructions, see [../setup-skill/SKILL.md](../setup-skill/SKILL.md)

For testing patterns, see:
- [../../testing/pytest-patterns/](../../testing/pytest-patterns/)
- [../../testing/test-utils/](../../testing/test-utils/)

Database integration: [../../data/database-skill/](../../data/database-skill/)

Why This is Wrong:
- ❌ Uses relative paths (../, ../../)
- ❌ Assumes hierarchical directory structure
- ❌ Breaks in flat deployment (~/.claude/skills/)
- ❌ Links break when skill deployed standalone

Correct Approach:

## Complementary Skills

Consider these related skills (if deployed):

- **setup-skill**: Installation and configuration patterns
- **pytest-patterns**: Testing framework and fixtures
- **database-skill**: Database integration patterns

*Note: All skills are independently deployable.*

❌ VIOLATION #2: Missing Essential Content

## Testing

This skill uses pytest for testing.

**See pytest-patterns skill for all testing code.**

To write tests for this framework, install pytest-patterns skill
and refer to its documentation.

Why This is Wrong:
- ❌ No actual testing patterns included
- ❌ Requires user to have another skill
- ❌ Skill is incomplete without other skills
- ❌ "See other skill" instead of inlining

Correct Approach:

## Testing (Self-Contained)

**Essential pytest pattern** (inlined):

```python
import pytest
from example_framework.testing import TestClient

@pytest.fixture
def client():
    """Test client fixture."""
    return TestClient(app)

def test_home_route(client):
    """Test homepage."""
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello"}

Advanced fixtures (if pytest-patterns skill deployed):
- Parametrized fixtures
- Database session fixtures
- Mock fixtures

See pytest-patterns skill for comprehensive patterns.

---

## ❌ VIOLATION #3: Hard Skill Dependencies

```markdown
## Prerequisites

**Required Skills**:
1. **setup-skill** - Must be installed first
2. **database-skill** - Required for database operations
3. **pytest-patterns** - Required for testing

Install all required skills before using this skill:
```bash
claude-code skills add setup-skill database-skill pytest-patterns

This skill will not work without these dependencies.

**Why This is Wrong**:
- ❌ Lists other skills as "Required"
- ❌ Skill doesn't work standalone
- ❌ Creates deployment coupling
- ❌ Violates self-containment principle

**Correct Approach**:
```markdown
## Prerequisites

**External Dependencies**:
```bash
pip install example-framework pytest sqlalchemy

Complementary Skills

When using this skill, consider (if deployed):
- setup-skill: Advanced configuration patterns (optional)
- database-skill: ORM patterns and optimization (optional)
- pytest-patterns: Testing enhancements (optional)

This skill is fully functional independently.

---

## ❌ VIOLATION #4: Cross-Skill Imports

```python
"""
Bad example - importing from other skills.
"""

# ❌ DON'T DO THIS
from skills.database_skill import get_db_session
from skills.pytest_patterns import fixture_factory
from ..shared.utils import validate_input

# Using imported patterns
@app.route("/users")
def create_user(data):
    # Requires database-skill to be installed
    with get_db_session() as session:
        user = User(**data)
        session.add(user)
        return user.to_dict()

Why This is Wrong:
- ❌ Imports from other skills
- ❌ Code won't run without other skills
- ❌ Creates runtime dependencies
- ❌ Violates Python module boundaries

Correct Approach:

"""
Good example - self-contained implementation.
"""
from contextlib import contextmanager

# ✅ Include pattern directly in this skill
@contextmanager
def get_db_session():
    """Database session context manager (self-contained)."""
    db = SessionLocal()
    try:
        yield db
        db.commit()
    except Exception:
        db.rollback()
        raise
    finally:
        db.close()

@app.route("/users")
def create_user(data):
    # Works independently
    with get_db_session() as session:
        user = User(**data)
        session.add(user)
        return user.to_dict()

❌ VIOLATION #5: Hierarchical Directory Assumptions

## Project Structure

This skill is located in:

toolchains/python/frameworks/bad-example-skill/

**Navigate to parent directories for related skills**:
- `../` - Other framework skills
- `../../testing/` - Testing skills
- `../../data/` - Database skills

**All skills in `toolchains/python/frameworks/` are related to this skill.**

Why This is Wrong:
- ❌ Assumes specific directory structure
- ❌ Navigation instructions using relative paths
- ❌ Won't work in flat deployment
- ❌ Confuses deployment location with skill relationships

Correct Approach:

## Related Skills

**Complementary Python Framework Skills** (informational):

- **fastapi-patterns**: Web framework patterns
- **django-patterns**: Full-stack framework patterns
- **flask-patterns**: Micro-framework patterns

**Testing Skills**:
- **pytest-patterns**: Testing framework
- **test-driven-development**: TDD workflow

*Note: Skills are independently deployable. Directory structure may vary.*

❌ VIOLATION #6: Incomplete Examples

# Database setup
# (See database-skill for complete implementation)

class User(db.Model):
    # ... see database-skill for model definition ...
    pass

# Testing
# (See pytest-patterns for test examples)

def test_user():
    # ... see pytest-patterns for fixtures ...
    pass

# Deployment
# (See deployment-skill for production setup)

Why This is Wrong:
- ❌ Examples are fragments, not complete code
- ❌ "See other skill" instead of showing code
- ❌ Users can't copy-paste and run
- ❌ Skill provides no actual implementation guidance

Correct Approach:

# Complete database model (self-contained)
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    """User model - complete implementation."""
    __tablename__ = "users"

    id = Column(Integer, primary_key=True)
    username = Column(String(80), unique=True, nullable=False)
    email = Column(String(120), unique=True, nullable=False)

    def to_dict(self):
        return {
            "id": self.id,
            "username": self.username,
            "email": self.email
        }

# Complete test example (self-contained)
import pytest
from example_framework.testing import TestClient

@pytest.fixture
def client():
    return TestClient(app)

def test_create_user(client):
    """Test user creation - complete working test."""
    response = client.post("/users", json={
        "username": "testuser",
        "email": "[email protected]"
    })
    assert response.status_code == 201
    assert response.json()["username"] == "testuser"

# Complete deployment example (self-contained)
import os

class ProductionConfig:
    DEBUG = False
    SECRET_KEY = os.getenv("SECRET_KEY")
    DATABASE_URL = os.getenv("DATABASE_URL")

app = App(config=ProductionConfig())

# Run with: gunicorn -w 4 app:app

❌ VIOLATION #7: References Directory with Cross-Skill Paths

bad-example-skill/
├── SKILL.md
├── metadata.json
└── references/
    ├── testing.md          # Contains: ../../pytest-patterns/
    ├── database.md         # Contains: ../../database-skill/
    └── deployment.md       # Contains: ../../../universal/deployment/

references/testing.md contains:

# Testing Patterns

For complete testing patterns, see:
- [Pytest Patterns](../../pytest-patterns/SKILL.md)
- [TDD Workflow](../../../universal/testing/test-driven-development/)

Refer to those skills for all testing code.

Why This is Wrong:
- ❌ References directory has cross-skill paths
- ❌ Progressive disclosure leads outside skill
- ❌ Breaks in flat deployment
- ❌ References aren't self-contained

Correct Approach:

good-example-skill/
├── SKILL.md
├── metadata.json
└── references/
    ├── advanced-patterns.md    # All about THIS skill
    ├── api-reference.md        # THIS skill's API
    └── examples.md             # THIS skill's examples

references/advanced-patterns.md should contain:

# Advanced Testing Patterns

**Advanced pytest fixtures** (this skill):

```python
# Parametrized test fixture
@pytest.fixture(params=["value1", "value2"])
def data_variants(request):
    return request.param

def test_with_variants(data_variants):
    # Test with multiple data variants
    assert process(data_variants) is not None

Further enhancements (if pytest-patterns deployed):
- Fixture factories
- Custom markers
- Plugin integration

See pytest-patterns skill for comprehensive advanced patterns.

---

## ❌ VIOLATION #8: metadata.json with Skill Dependencies

```json
{
  "name": "bad-example-skill",
  "version": "1.0.0",
  "requires": [
    "setup-skill",
    "database-skill",
    "pytest-patterns"
  ],
  "self_contained": false,
  "dependencies": ["example-framework"],
  "notes": [
    "This skill requires setup-skill to be installed first",
    "Must deploy with database-skill for database operations",
    "Won't work without pytest-patterns for testing"
  ]
}

Why This is Wrong:
- ❌ Lists other skills in "requires" field
- ❌ "self_contained": false
- ❌ Notes say skill won't work without others
- ❌ Creates deployment coupling

Correct Approach:

{
  "name": "good-example-skill",
  "version": "1.0.0",
  "requires": [],
  "self_contained": true,
  "dependencies": ["example-framework", "pytest", "sqlalchemy"],
  "complementary_skills": [
    "setup-skill",
    "database-skill",
    "pytest-patterns"
  ],
  "notes": [
    "This skill is fully self-contained and works independently",
    "All essential patterns are inlined",
    "Complementary skills provide optional enhancements"
  ]
}

Summary of Violations

Violation	Example	Impact
Relative Paths	`../../other-skill/`	Breaks in flat deployment
Missing Content	"See other skill for X"	Incomplete, not self-sufficient
Hard Dependencies	"Requires other-skill"	Can't deploy standalone
Cross-Skill Imports	`from skills.other import`	Runtime dependency
Hierarchical Assumptions	"Navigate to parent dir"	Location-dependent
Incomplete Examples	Code fragments only	Not usable
References Cross-Skill	`references/` has `../`	Progressive disclosure broken
Metadata Dependencies	`"requires": ["skill"]`	Deployment coupling

How to Fix These Violations

Step 1: Remove All Relative Paths

# Find violations
grep -r "\.\\./" bad-example-skill/

# Remove them - use skill names instead
# ❌ [skill](../../skill/SKILL.md)
# ✅ skill (if deployed)

Step 2: Inline Essential Content

# Before (wrong):
## Testing
See pytest-patterns skill for all testing code.

# After (correct):
## Testing (Self-Contained)

**Essential pattern** (inlined):
[20-50 lines of actual testing code]

**Advanced patterns** (if pytest-patterns deployed):
- Feature list

*See pytest-patterns for comprehensive guide.*

Step 3: Remove Hard Dependencies

# Before (wrong):
**Required Skills**: pytest-patterns, database-skill

# After (correct):
**Complementary Skills** (optional):
- pytest-patterns: Testing enhancements
- database-skill: ORM optimization

Step 4: Make Imports Self-Contained

# Before (wrong):
from skills.database import get_db_session

# After (correct):
@contextmanager
def get_db_session():
    """Inlined pattern."""
    # Implementation here

Step 5: Update metadata.json

// Before (wrong):
{
  "requires": ["other-skill"],
  "self_contained": false
}

// After (correct):
{
  "requires": [],
  "self_contained": true,
  "complementary_skills": ["other-skill"]
}

Verification

After fixing, verify self-containment:

# Should return empty (no violations)
grep -r "\.\\./" skill-name/
grep -r "from skills\." skill-name/
grep -i "requires.*skill" skill-name/SKILL.md

# Isolation test
cp -r skill-name /tmp/skill-test/
cd /tmp/skill-test/skill-name
cat SKILL.md  # Should be complete and useful

# Metadata check
cat metadata.json | jq '.requires'  # Should be [] or external packages only

See Good Example Instead

DO NOT USE THIS EXAMPLE AS A TEMPLATE

Instead, see:
- good-self-contained-skill: Correct template
- SKILL_SELF_CONTAINMENT_STANDARD.md: Complete standard

Remember: This example shows what NOT to do. Always ensure your skills are self-contained!

# README.md

Claude MPM Skills

Production-ready Claude Code skills for intelligent project development

Overview

This repository contains a comprehensive collection of 110 Claude Code skills designed for the Claude Multi-Agent Project Manager (MPM) ecosystem. Skills cover modern development workflows with 95%+ coverage across Python, TypeScript, JavaScript, Golang, PHP, Rust, Elixir, AI, and universal tooling.

What is Claude MPM?

Claude MPM (Multi-Agent Project Manager) is an advanced orchestration framework that runs within Claude Code (Anthropic's official CLI). It enables:

Multi-Agent Coordination: Specialized agents for different tasks (research, engineering, QA, ops)
Intelligent Delegation: PM agent coordinates work across specialist agents
Context Management: Efficient token usage with progressive disclosure
Skill System: Modular, reusable knowledge bases (this repository)

Key Components:
- Claude Code: Anthropic's official CLI environment
- Claude MPM: Multi-agent framework running in Claude Code
- Skills: Domain-specific knowledge modules (this repo contains 110 skills)

How They Work Together:

Claude Code (CLI)
    ↓
Claude MPM (Multi-Agent Framework)
    ↓
Skills (Knowledge Modules) ← You are here

Features

Progressive Loading: Skills load on-demand with compact entry points, expanding to full references when needed
Token Efficiency: ~87% token savings during discovery phase
Toolchain Detection: Automatically deploy relevant skills based on project type
Production-Ready: All skills include real-world examples, best practices, and troubleshooting
Research-Backed: Built on latest 2025 techniques and industry patterns

Quick Stats

Total Skills: 110 production-ready skills
Coverage: 95%+ of modern development workflows
Token Efficiency: ~66.7k entry tokens vs ~512.4k full tokens (~87% savings)
Categories: Python, TypeScript, JavaScript, Golang, PHP, Rust, Elixir, Next.js, UI, AI, Platforms, Universal
Complete Stacks: Full-stack TypeScript, Python Web, React Frontend, AI Workflows

Repository Structure

claude-mpm-skills/
├── toolchains/          # Language/framework-specific skills (76 skills)
│   ├── python/         # 10 skills
│   │   ├── frameworks/     # Django, FastAPI, Flask
│   │   ├── testing/        # pytest
│   │   ├── data/           # SQLAlchemy
│   │   ├── async/          # asyncio, Celery
│   │   ├── tooling/        # mypy, pyright
│   │   └── validation/     # Pydantic
│   ├── typescript/     # 13 skills
│   │   ├── frameworks/     # React, Vue, Node.js backend, Fastify
│   │   ├── testing/        # Vitest, Jest
│   │   ├── data/           # Drizzle, Kysely, Prisma
│   │   ├── validation/     # Zod
│   │   ├── state/          # Zustand, TanStack Query
│   │   ├── api/            # tRPC
│   │   └── build/          # Turborepo
│   ├── javascript/     # 12 skills
│   │   ├── frameworks/     # React, Vue, Svelte, SvelteKit
│   │   ├── testing/        # Playwright, Cypress
│   │   ├── build/          # Vite
│   │   └── tooling/        # Biome
│   ├── php/            # 6 skills
│   │   ├── frameworks/     # WordPress, EspoCRM
│   │   └── testing/        # PHPUnit, PHPCS
│   ├── golang/         # 7 skills
│   │   ├── web/            # net/http, Chi, Gin, Echo, Fiber
│   │   ├── testing/        # Go testing, testify, httptest
│   │   ├── data/           # SQL, migrations, ORMs/query builders
│   │   ├── cli/            # CLI tooling patterns
│   │   └── observability/  # Logging and telemetry
│   │   ├── grpc/           # Protobuf APIs, interceptors, streaming
│   │   └── concurrency/    # errgroup, worker pools, bounded fan-out
│   ├── rust/           # 4 skills
│   │   ├── frameworks/     # Tauri, Axum
│   │   ├── cli/            # Clap
│   │   └── desktop-applications/ # Desktop app patterns
│   ├── elixir/         # 4 skills
│   │   ├── frameworks/     # Phoenix + LiveView (BEAM), Phoenix API + Channels
│   │   ├── data/           # Ecto patterns
│   │   └── ops/            # Phoenix operations & releases
│   ├── nextjs/         # 2 skills
│   │   ├── core/           # Next.js fundamentals
│   │   └── v16/            # Next.js 16 (Turbopack, cache components)
│   ├── ui/             # 4 skills
│   │   ├── styling/        # Tailwind CSS
│   │   └── components/     # shadcn/ui, DaisyUI, Headless UI
│   ├── ai/             # 7 skills
│   │   ├── sdks/           # Anthropic SDK
│   │   ├── frameworks/     # LangChain, DSPy, LangGraph
│   │   ├── services/       # OpenRouter
│   │   ├── protocols/      # MCP
│   │   └── techniques/     # Session Compression
│   └── platforms/      # 4 skills
│       ├── deployment/     # Vercel, Netlify
│       ├── database/       # Neon
│       └── backend/        # Supabase
└── universal/           # 32 skills
    ├── infrastructure/     # Docker, GitHub Actions
    ├── data/              # GraphQL
    ├── architecture/      # Software patterns
    └── testing/           # TDD, systematic debugging

Complete Skill Catalog

Python (10 Skills)

Frameworks:
- Django - Full-featured web framework with ORM, admin, DRF
- FastAPI - Modern async API framework with automatic OpenAPI
- Flask - Lightweight WSGI framework for microservices

Testing:
- pytest - Fixtures, parametrization, plugins, FastAPI/Django integration

Data & ORM:
- SQLAlchemy - Modern ORM with 2.0 syntax, async, Alembic migrations

Async & Background Jobs:
- asyncio - Async/await patterns, event loops, concurrent programming
- Celery - Distributed task queues, periodic tasks, workflows

Type Checking:
- mypy - Static type checker with strict mode
- pyright - Fast type checker with VS Code integration

Validation:
- Pydantic - Data validation with type hints, FastAPI/Django integration

TypeScript (13 Skills)

Frameworks:
- React - Hooks, context, performance optimization
- Vue 3 - Composition API, Pinia, TypeScript integration
- Node.js Backend - Express/Fastify with Drizzle/Prisma
- Fastify - Schema-first, high-performance backend with typed routes

Testing:
- Vitest - Modern testing with React/Vue
- Jest - TypeScript testing with ts-jest

Data & ORMs:
- Drizzle - TypeScript-first ORM with migrations
- Kysely - Type-safe SQL query builder
- Prisma - Next-gen ORM with migrations and client generation

Validation:
- Zod - Schema validation with type inference

State Management:
- Zustand - Minimal React state management
- TanStack Query - Server state, caching, optimistic updates

API:
- tRPC - End-to-end type safety without codegen

Build Tools:
- Turborepo - Monorepo with intelligent caching

JavaScript (12 Skills)

Frameworks:
- React - Component patterns (also in TypeScript)
- Vue - Progressive framework (also in TypeScript)
- Svelte - Reactive framework with runes
- SvelteKit - Full-stack Svelte with SSR/SSG
- Svelte 5 Runes + adapter-static - Hydration-safe state and store bridges

Testing:
- Playwright - Cross-browser E2E testing with Page Object Model
- Cypress - Browser E2E testing with network stubbing and component testing

Build Tools:
- Vite - Fast build tool with HMR

Tooling:
- Biome - Fast linter and formatter (Rust-powered)

PHP (6 Skills)

WordPress Ecosystem:
- wordpress-advanced-architecture - REST API, WP-CLI, performance optimization, caching strategies
- wordpress-block-editor - Block themes, FSE architecture, theme.json, custom Gutenberg blocks
- wordpress-testing-qa - PHPUnit integration tests, WP_Mock unit tests, PHPCS coding standards

Enterprise:
- espocrm-development - EspoCRM customization, entity management, API extensions
- espocrm-advanced-features - Advanced workflows, complex business logic implementation
- espocrm-deployment - Production deployment, security hardening, performance tuning

Golang (7 Skills)

Web & HTTP:
- golang-http-frameworks - net/http, Chi, Gin, Echo, Fiber patterns

gRPC:
- golang-grpc - Protobuf APIs, interceptors, streaming, bufconn testing

Concurrency:
- golang-concurrency-patterns - Context, errgroup, worker pools, bounded fan-out

Testing:
- golang-testing-strategies - Table-driven tests, testify, gomock, benchmarks

Data:
- golang-database-patterns - SQL patterns, migrations, query builders

CLI:
- golang-cli-cobra-viper - Cobra/Viper CLI structure and config

Observability:
- golang-observability-opentelemetry - Logging/metrics/traces + middleware patterns

Rust (4 Skills)

Web & Desktop:
- axum - Production Rust HTTP APIs with Tower middleware
- desktop-applications - Rust desktop app architecture and integration patterns
- tauri - Cross-platform desktop apps with Rust backend and web frontend

CLI:
- clap - Rust CLI parsing, subcommands, config layering, testable binaries

Next.js (2 Skills)

Next.js Core - App Router, Server Components, Server Actions
Next.js v16 - Turbopack, cache components, migration guide

UI & Styling (4 Skills)

CSS Frameworks:
- Tailwind CSS - Utility-first CSS with JIT mode

Component Libraries:
- shadcn/ui - Copy-paste components with Radix UI + Tailwind
- DaisyUI - Tailwind plugin with 50+ components and themes
- Headless UI - Unstyled accessible primitives for React/Vue

AI & LLM (7 Skills)

SDKs:
- Anthropic SDK - Messages API, streaming, function calling, vision

Frameworks:
- LangChain - LCEL, RAG, agents, chains, memory
- DSPy - Automatic prompt optimization with MIPROv2
- LangGraph - Stateful multi-agent orchestration

Services:
- OpenRouter - Unified LLM API access

Protocols:
- MCP - Model Context Protocol

Techniques:
- Session Compression - Context window compression, progressive summarization

Platforms (4 Skills)

Deployment:
- Vercel - Next.js deployment, Edge Functions, serverless
- Netlify - JAMstack, Forms, Identity, Edge Functions

Database:
- Neon - Serverless Postgres with branching

Backend:
- Supabase - Postgres + Auth + Storage + Realtime + RLS

Universal (32 Skills)

Infrastructure:
- Docker - Containerization, multi-stage builds, compose
- GitHub Actions - CI/CD workflows, matrix strategies, deployments
- Kubernetes - Workloads, probes, rollouts, debugging runbook, hardening
- Terraform - IaC workflow: state, modules, environments, CI guardrails

Observability:
- OpenTelemetry - Traces/metrics/logs, OTLP + Collector pipelines, sampling, troubleshooting

Security:
- Threat Modeling - STRIDE workshops, threat registers, mitigations → tickets + tests

Data:
- GraphQL - Schema-first APIs, Apollo, resolvers, subscriptions

Architecture:
- Software Patterns - Design patterns, anti-patterns, decision trees

Testing & Debugging:
- TDD - Test-driven development workflows
- Systematic Debugging - Root cause analysis

Installation

Prerequisites

Claude Code (Anthropic's official CLI)
Claude MPM framework

Step 1: Install Claude MPM

# Install via pip (recommended)
pip install claude-mpm

# Or install via Homebrew (macOS)
brew tap bobmatnyc/tools
brew install claude-mpm

# Or install from source
git clone https://github.com/bobmatnyc/claude-mpm.git
cd claude-mpm
pip install -e .

Step 2: Initialize Claude MPM in Your Project

# Navigate to your project directory
cd your-project

# Initialize Claude MPM
/mpm-init

This creates .claude-mpm/ directory with configuration and agent setup.

Step 3: Deploy Skills (Automatic)

# Auto-detect your project stack and deploy relevant skills
/mpm-auto-configure

# Or use the agent auto-configuration
/mpm-agents-auto-configure

Skills are automatically selected based on:
- package.json → TypeScript/JavaScript skills
- pyproject.toml → Python skills
- Framework configs → Next.js, React, Django, FastAPI
- Dependencies → AI frameworks (LangChain, Anthropic)

Step 4: Verify Installation

# Check MPM status
/mpm-status

# List available skills
/mpm-agents-list

# View deployed agents
/mpm-agents

Manual Skill Installation (Alternative)

Clone this repository to make skills available to Claude MPM:

# Clone skills repository
git clone https://github.com/bobmatnyc/claude-mpm-skills.git

# Link to Claude MPM skills directory
ln -s $(pwd)/claude-mpm-skills ~/.claude-mpm/skills

Usage

Automatic Deployment (Recommended)

# Initialize project with Claude MPM
/mpm-init

# Or use auto-configuration to detect toolchain
/mpm-auto-configure

# Deploy recommended skills based on project detection
/mpm-agents-auto-configure

Skills are automatically deployed based on detected toolchain:
- package.json → TypeScript/JavaScript skills
- pyproject.toml or requirements.txt → Python skills
- Framework configs → Next.js, React, Django, FastAPI skills
- AI dependencies → LangChain, Anthropic, DSPy skills

Manual Skill Access

Skills use progressive loading - entry points load first for quick reference:

---
progressive_disclosure:
  entry_point:
    summary: "Brief description (60-95 tokens)"
    when_to_use:
      - "Use case 1"
      - "Use case 2"
    quick_start:
      - "Step 1"
      - "Step 2"
---

Full documentation expands on-demand when needed.

Complete Development Stacks

Full-Stack TypeScript

Next.js + tRPC + TanStack Query + Zustand + Zod + Prisma +
Tailwind + shadcn/ui + Turborepo + Docker + GitHub Actions

Coverage: 100% - All skills available

Python Web Development

FastAPI/Django + Pydantic + SQLAlchemy + Celery +
pytest + mypy + Docker + GitHub Actions

Coverage: 100% - All skills available

Modern React Frontend

React + TanStack Query + Zustand + Tailwind + shadcn/ui +
Vite + Vitest + Playwright

Coverage: 100% - All skills available

AI/LLM Applications

Anthropic SDK + LangChain + DSPy + LangGraph +
Session Compression + OpenRouter + MCP

Coverage: 100% - All skills available

Progressive Loading Design

Skills use a two-tier structure for optimal token efficiency:

Entry Point (60-200 tokens, depending on skill depth)

Skill name and summary
When to use (3-5 scenarios)
Quick start (3-5 steps)

Full Documentation (3,000-6,000 tokens)

Complete API reference
Real-world examples
Best practices
Framework integrations
Production patterns
Testing strategies
Troubleshooting

Token Savings: ~87% during discovery (load 110 entry points vs all full docs)

Performance Benchmarks

Discovery Phase: 66,690 tokens (all 110 entry points) vs 512,411 tokens (all full docs)
Token Efficiency: ~87% reduction during skill browsing
Coverage: 95%+ of modern development workflows
Production Adopters: Skills based on patterns from JetBlue, Databricks, Walmart, VMware
Token Reporting: python scripts/token_report.py --manifest manifest.json --out stats/token-summary.json for CI/dashboard consumption

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

Governance: All merges to main require approval from @bobmatnyc (see GOVERNANCE.md)

Skill Format Requirements

Progressive Disclosure: YAML frontmatter with entry_point section
Token Budgets: Entry 60-200 tokens, Full 3,000-6,000 tokens
Metadata: Complete metadata.json with tags, related_skills, token estimates
Examples: Real-world code examples with error handling
Versioning: Semantic versioning (see docs/VERSIONING.md)

Documentation

User Documentation

User Guide - Understanding and using Claude Code skills
Troubleshooting - Common issues and solutions

Developer Documentation

Skill Creation Guide - Building your own skills
Best Practices - Self-containment standards
Contributing - Contribution guidelines
Versioning Policy - Semantic versioning for skills

Architecture & Research

Architecture - Repository structure
Research Documents - Pattern analysis and guides
Python, TypeScript, Ruby, Rust, PHP, Java, Go advanced patterns
Skills compliance analysis
Coverage analysis

Reference

PR Checklist - Submission requirements
GitHub Setup - Repository configuration

License

MIT License - See LICENSE

Acknowledgments

Built with research from:
- Official framework documentation (2025 versions)
- Industry best practices (JetBlue, Databricks, Walmart, VMware, Replit)
- Academic research (DSPy, LLMLingua, prompt optimization studies)
- Community feedback and contributions

Last Updated: 2025-12-17
Skills Count: 110
Coverage: 95%+
Token Efficiency: ~87%

# Supported AI Coding Agents

This skill is compatible with the SKILL.md standard and works with all major AI coding agents:

⚡ Amp 🚀 Antigravity 🤖 Claude Code 🦀 Clawdbot 📝 Codex ▶️ Cursor 🤖 Droid 💎 Gemini CLI 🐙 GitHub Copilot 🪿 Goose 📊 Kilo Code 🔧 Kiro CLI 💻 OpenCode 🦘 Roo Code 🌲 Trae 🏄 Windsurf

Learn more about the SKILL.md standard and how to use these skills with your preferred AI coding agent.

bad-example-skill

# Description

# SKILL.md

⚠️ BAD EXAMPLE - Interdependent Skill (Anti-Pattern)

❌ VIOLATION #1: Relative Path Dependencies

❌ VIOLATION #2: Missing Essential Content

Complementary Skills

❌ VIOLATION #5: Hierarchical Directory Assumptions

❌ VIOLATION #6: Incomplete Examples

❌ VIOLATION #7: References Directory with Cross-Skill Paths

Summary of Violations

How to Fix These Violations

Step 1: Remove All Relative Paths

Step 2: Inline Essential Content

Step 3: Remove Hard Dependencies

Step 4: Make Imports Self-Contained

Step 5: Update metadata.json

Verification

See Good Example Instead

# README.md

Claude MPM Skills

Overview

What is Claude MPM?

Features

Quick Stats

Repository Structure

Complete Skill Catalog

Python (10 Skills)

TypeScript (13 Skills)

JavaScript (12 Skills)

PHP (6 Skills)

Golang (7 Skills)

Rust (4 Skills)

Next.js (2 Skills)

UI & Styling (4 Skills)

AI & LLM (7 Skills)

Platforms (4 Skills)

Universal (32 Skills)

Installation

Prerequisites

Step 1: Install Claude MPM

Step 2: Initialize Claude MPM in Your Project

Step 3: Deploy Skills (Automatic)

Step 4: Verify Installation

Manual Skill Installation (Alternative)

Usage

Automatic Deployment (Recommended)

Manual Skill Access

Complete Development Stacks

Full-Stack TypeScript

Python Web Development

Modern React Frontend

AI/LLM Applications

Progressive Loading Design

Entry Point (60-200 tokens, depending on skill depth)

Full Documentation (3,000-6,000 tokens)

Performance Benchmarks

Contributing

Skill Format Requirements

Documentation

User Documentation

Developer Documentation

Architecture & Research

Reference

License

Links

Acknowledgments

# Related Skills

# Supported AI Coding Agents

Confirm

Submit a Skill