# How Claude and Cursor Skill Integrations Work in AI Engineering from Scratch > Discover how Claude and Cursor skill integrations work in AI Engineering from Scratch. Learn about SKILL.md artifacts and MCP for seamless reusable capability discovery and execution. - Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch) - Tags: deep-dive - Published: 2026-06-07 --- **AI Engineering from Scratch implements a universal skill system using SKILL.md artifacts and the Model-Context Protocol (MCP) that enables both Claude Code and Cursor to automatically discover, register, and execute reusable capabilities as slash commands.** The open-source curriculum **rohitg00/ai-engineering-from-scratch** provides a model-agnostic framework for extending AI assistant capabilities through reusable skills. Its Claude and Cursor skill integrations rely on three tightly-coupled architectural components that ensure any skill authored once works seamlessly across multiple agents without platform-specific modifications. ## The Three Core Components ### SKILL.md Files **SKILL.md** files serve as plain-text capability definitions located at `phases///outputs/skill-.md`. Each file contains YAML front-matter specifying `name`, `description`, `phase`, and `lesson`, followed by a Markdown body containing the implementation logic. Both Claude Code and Cursor scan the repository for these files, parse the front-matter, and register slash-commands (such as `/check-understanding`) that appear directly in the chat UI. ### Model-Context Protocol (MCP) The **MCP (Model-Context Protocol)** is a universal JSON-RPC-style wire format for exposing tools, resources, and prompts to LLM agents. Claude Desktop and Cursor embed MCP clients that discover the skill's tool schema, call the underlying implementation, and stream results back to the model. This architecture guarantees *one implementation, many agents*, allowing the same skill to work with Codex, OpenClaw, Hermes, or any future MCP-compatible client. ### Installation Script The **[`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py)** utility orchestrates skill registration by walking the repository structure, identifying every `skill-*.md` file via glob patterns, and registering them with the local MCP client. The script copies skills into agent-specific directories (`.claude/skills/…` and `cursor/skills/…`) so each agent can read from its standard search path. Running `python scripts/install_skills.py` or the npm wrapper `npx skills add` makes capabilities instantly available across both Claude and Cursor without manual file copying. ## Architectural Flow: From Author to Execution The integration follows a five-step pipeline that maintains a single source of truth for skill definitions: 1. **Authoring**: Lesson authors create `phases///outputs/skill-.md` with YAML metadata and implementation code. 2. **Discovery**: The installation script executes `glob "**/skill-*.md"` to locate all skill definitions. 3. **Registration**: The script copies files to `.claude/skills/` and `cursor/skills/`, then calls the MCP client's `registerSkill` endpoint to store metadata in the server's catalog. 4. **UI Exposure**: Claude Desktop and Cursor read the MCP catalog on startup and automatically surface slash-commands for each registered skill. 5. **Invocation**: When users execute `/find-your-level` or similar commands, the agent sends an MCP request (`POST /skill/`) with model-generated arguments. The MCP server executes the underlying Python script and returns results to the chat stream. ## Implementation Details by Source File According to **[`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md)**, the system explicitly supports Claude Code, Cursor, Codex, OpenClaw, and Hermes as first-class MCP consumers. The **[`site/data.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/data.js)** file references "Cursor's Dynamic Context Loading" as evidence of Cursor's MCP client implementation. The concrete orchestration logic resides in **[`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py)**, which handles the directory traversal and MCP client registration. The protocol specification lives in **[`phases/11-llm-engineering/14-model-context-protocol/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/11-llm-engineering/14-model-context-protocol/docs/en.md)**, defining the JSON-RPC schema that agents use to communicate with the skill server. The **[`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md)** (lines 129-151) documents the user-facing installation command `npx skills add` for cross-platform skill deployment. ## Practical Code Examples ### Minimal SKILL.md Structure ```markdown --- name: add-two-numbers description: Simple arithmetic skill – adds two integers. phase: 14 lesson: 10 --- # Usage Provide two numbers and the skill returns their sum. ```python import sys a, b = map(int, sys.argv[1:3]) print(a + b) ``` ``` When installed, both Claude Code and Cursor expose `/add-two-numbers` as a slash-command. The MCP client runs the Python snippet with arguments supplied by the model and streams the computed result back to the conversation. ### Installing All Skills ```bash # From the repository root python scripts/install_skills.py # Or using the npm wrapper npx skills add ``` After execution, skills appear in both Claude Desktop and Cursor without restarting the applications or modifying configuration files. ### Calling a Skill from Claude ```text User: /add-two-numbers 7 13 Claude: 20 ``` The model emits the slash-command, the Claude Code client translates it to an MCP request, executes the Python script, and returns the answer. ## Summary - **SKILL.md** files in `phases///outputs/` define reusable capabilities using YAML front-matter and Markdown bodies. - The **Model-Context Protocol** provides a JSON-RPC wire format that enables Claude, Cursor, and other agents to consume skills through a unified interface. - **[`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py)** automates discovery, copying skills to `.claude/skills/` and `cursor/skills/` directories while registering them with the MCP server. - Skills appear as **slash-commands** (e.g., `/check-understanding`) immediately after running `npx skills add`. - The architecture is **model-agnostic**, ensuring skills work across Claude Code, Cursor, Codex, and future MCP-compatible clients without modification. ## Frequently Asked Questions ### What file format do skills use in AI Engineering from Scratch? Skills use a **SKILL.md** format consisting of YAML front-matter containing metadata fields (`name`, `description`, `phase`, `lesson`) followed by a Markdown implementation body. These files reside in `phases///outputs/skill-.md` and contain either Python scripts or prompt templates that the MCP server executes. ### How do Claude and Cursor discover new skills? Both agents discover skills through the **installation script** ([`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py)), which copies SKILL.md files into agent-specific directories (`.claude/skills/` and `cursor/skills/`) and registers them with the MCP server catalog. The agents read this catalog on startup and automatically expose each skill as a slash-command in their respective UIs. ### Can skills work with AI assistants other than Claude and Cursor? Yes. The **Model-Context Protocol** is designed to be agent-agnostic. The [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) file lists support for Claude Code, Cursor, Codex, OpenClaw, and Hermes. Any AI assistant that implements an MCP client can consume the same skill files without requiring format changes or separate implementations. ### Where is the MCP protocol specification defined in the repository? The **JSON-RPC schema** and protocol specification are documented in [`phases/11-llm-engineering/14-model-context-protocol/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/11-llm-engineering/14-model-context-protocol/docs/en.md). This file defines how agents communicate with the skill server, including request formats, tool discovery mechanisms, and result streaming protocols that both Claude and Cursor implement.