--- marp: true theme: default paginate: true --- # MCPs vs Skills — A Debate **Date:** Wednesday, April 29, 2026 · 13:30 MT **Format:** Panel-style roundtable --- # Speakers ## Jae Wilson **Domo COE Architect & Consultant, DataCrew LLC** Former Sony Staff Engineer. Maintains Python library for Domo APIs. YouTube: @datacrew.space ## Jonathan Tiritilli **Principal Applied AI Engineer, Domo, Inc.** Enabling teams to adopt AI technologies. Architecting RAG, ontology, and semantic layers. Temecula, CA. --- # What You'll Get Out of This 1. **Understand what MCP actually is** — not the hype 2. **See the context rot problem** — why tool definitions bloat your context 3. **Compare how Claude handles tools vs skills** — different loading strategies 4. **Walk away with a mental model** — when to use each approach --- # Announcements ## 📬 Newsletter Launching Soon Sign up at [datacrew.space](https://datacrew.space) for Domo tips, AI workflows, and consulting insights. ## 📚 crew-dcs (domolibrary) — Free with Registration Python SDK for Domo APIs. Register at [datacrew.space](https://datacrew.space) to get access. ## ☕ Support the Channel - **Venmo:** [@JaeMyong-Wilson](https://venmo.com/@JaeMyong-Wilson) — personal support - **Business expense:** Pay what you want via Stripe (coming soon) --- # Part 1: What is MCP? --- # MCP = Model Context Protocol > "MCP is an API for AI" — designed assuming the consumer is a model, not a human developer. **Created by:** Anthropic (open-sourced 2024) **Purpose:** Standardized way for AI models to: - Discover tools - Call tools with structured inputs - Receive structured outputs - Access resources (data) --- # MCP Architecture ``` ┌─────────────────┐ JSON-RPC ┌─────────────────┐ │ AI Client │ ◄─────────────────► │ MCP Server │ │ (Claude, etc) │ │ (your tools) │ └─────────────────┘ └─────────────────┘ │ │ │ Tool definitions + results │ API calls ▼ ▼ Context Window External Systems ``` --- # MCP Server Example: GitHub Tools ```python from fastmcp import FastMCP mcp = FastMCP("github-tools") @mcp.tool() def create_issue(owner: str, repo: str, title: str, body: str) -> str: """Create a GitHub issue. Args: owner: Repository owner (e.g., 'jaewilson07') repo: Repository name (e.g., 'simpleDiscordBot') title: Issue title body: Issue description Returns: URL of the created issue """ # Call GitHub API... return f"https://github.com/{owner}/{repo}/issues/123" @mcp.tool() def list_prs(owner: str, repo: str, state: str = "open") -> list[dict]: """List pull requests in a repository.""" # Call GitHub API... return [{"number": 42, "title": "Fix bug", "url": "..."}] ``` --- # MCP Server Example: GitHub Tools (cont.) ```python @mcp.resource("github://repos/{owner}/{repo}") def repo_info(owner: str, repo: str) -> str: """Get repository metadata.""" return json.dumps({"stars": 150, "forks": 30, "language": "Python"}) if __name__ == "__main__": mcp.run() # Starts STDIO transport ``` **Running it:** ```bash python github_mcp_server.py # or npx @modelcontextprotocol/inspector python github_mcp_server.py ``` --- # Part 2: Context Rot --- # The Problem: Tool Definitions Consume Tokens **Every MCP tool = 500-900 tokens in context** ``` Tool: create_issue Description: Create a GitHub issue Parameters: owner (string): Repository owner (e.g., 'jaewilson07') repo (string): Repository name title (string): Issue title body (string): Issue description Returns: URL of the created issue Tool: list_prs Description: List pull requests... [another 500 tokens] ``` --- # Context Rot in Action **Scenario:** You have 50 MCP tools connected | Metric | Value | | ----------------------------- | ---------------------------- | | Tool definitions | 50 × 700 = **35,000 tokens** | | Context window (Claude) | 200,000 tokens | | **Context consumed by tools** | **17.5%** | | Remaining for conversation | 165,000 tokens | **This is context rot** — your tools eat your context before you even start. --- # Why This Matters 1. **Every message re-includes tool definitions** (in most implementations) 2. **Longer conversations = more token burn** 3. **Complex tools = more tokens** 4. **You pay for tokens whether you use the tool or not** --- # Part 3: How Claude Handles Tools vs Skills --- # Tools (MCP) — Always Loaded ``` ┌─────────────────────────────────────────┐ │ CONTEXT WINDOW │ ├─────────────────────────────────────────┤ │ [Tool definitions - ALWAYS PRESENT] │ │ - create_issue (700 tokens) │ │ - list_prs (650 tokens) │ │ - search_code (800 tokens) │ │ - ... (47 more tools) │ │ │ │ [Your conversation] │ │ User: "Create an issue..." │ │ Assistant: "I'll use create_issue..." │ └─────────────────────────────────────────┘ ``` **Tools are loaded at session start and stay in context.** --- # Skills — Progressive Disclosure ``` ┌─────────────────────────────────────────┐ │ CONTEXT WINDOW │ ├─────────────────────────────────────────┤ │ [Skill index - ~100 tokens] │ │ - /commit: Git commit workflow │ │ - /deploy: Deployment checklist │ │ - /review: Code review guide │ │ │ │ [Your conversation] │ │ User: "/commit" │ │ │ │ [NOW load the skill content] │ │ + commit-skill.md (2000 tokens) │ └─────────────────────────────────────────┘ ``` **Skills load on-demand. Only what you need, when you need it.** --- # Token Comparison | Approach | Initial Load | Per-Use Cost | Total (10 skills/tools) | | ------------- | ------------ | ------------ | ----------------------- | | **MCP Tools** | 7,000 tokens | 0 | 7,000 tokens | | **Skills** | 100 tokens | 500-2000 | 100 + (use × skill) | **If you only use 3 skills in a session:** - Skills: 100 + 3 × 1000 = **3,100 tokens** - MCP: **7,000 tokens** (all loaded always) --- # The Hybrid Pattern > "Skills teach agents how to do things. MCP servers give agents the ability to do things." — Speakeasy **Best of both worlds:** 1. **Skills define the workflow** — when to use which tool, what order, what to check 2. **MCP provides the tools** — API connections, data access, operations 3. **Together** — The skill teaches the agent WHEN and WHY to use the MCP tools --- # Example: Deploy Workflow **Skill (markdown file):** ```markdown # Deploy Checklist 1. Run tests: `pytest tests/` 2. Check coverage: `coverage report` 3. Build: `npm run build` 4. Deploy: Use the `deploy_service` MCP tool - Parameters: service_name, environment - Wait for health check 5. Verify: Use `check_deployment_status` MCP tool ``` **MCP Tools:** - `deploy_service` — triggers deployment - `check_deployment_status` — polls for completion --- # Key Takeaways 1. **MCP is not dead** — production users (Amazon, Uber, Docker) are doubling down 2. **Context rot is real** — every tool definition costs tokens 3. **Skills are more token-efficient** — progressive disclosure vs always-loaded 4. **They're complementary**: - Skills = knowledge layer (workflows, expertise) - MCP = execution layer (tools, data access) 5. **The winning pattern**: Skills teach, MCP connects --- # Resources - [MCP Specification](https://modelcontextprotocol.io) - [FastMCP (Python)](https://github.com/anthropics/fastmcp) - [Speakeasy: Skills vs MCP](https://speakeasy.com/blog/skills-vs-mcp) - [Aqfer: Long Live MCP](https://aqfer.com/long-live-mcp-a-recap-of-mcp-dev-summit-ny/) --- # Q&A **Jae Wilson** — jae@datacrew.space · linkedin.com/in/jaewor **Jonathan Tiritilli** — linkedin.com/in/jonathan-tiritilli-2b961446 --- # Next Steps 1. Try building an MCP server: `pip install fastmcp` 2. Check your tool token usage: `npx @anthropic-ai/token-counter` 3. Consider skills for workflows, MCP for tools 4. Join the Domo User Group Slack for more discussions