AI 编辑器扩展机制详解：MCP、Rule、Skills

AI 编辑器扩展机制详解：MCP、Rule、Skills

本文系统性地介绍 AI 编辑器的三大扩展机制，帮助开发者理解如何通过这些机制扩展 AI 能力、规范 AI 行为、封装 AI 技能。

目录

• 概述
• 一、MCP - 工具连接协议
• 二、Rule - 行为约束规则
• 三、Skills - 能力技能包
• 四、三者关系与协作
• 五、实际应用场景
• 六、最佳实践
• 七、总结

概述

现代 AI 编辑器（如 Cursor、GitHub Copilot、Codebuddy 等）不仅是代码补全工具，更是一个可扩展的智能开发平台。通过三大扩展机制，开发者可以：

┌─────────────────────────────────────────────────────────────┐
│                      AI 编辑器扩展生态                        │
├─────────────────┬─────────────────┬─────────────────────────┤
│      MCP        │      Rule       │        Skills           │
│   外部工具连接    │   行为约束规则   │      能力技能包          │
│   (执行层)       │   (约束层)       │      (能力层)           │
└─────────────────┴─────────────────┴─────────────────────────┘

一、MCP - 工具连接协议

1.1 什么是 MCP？

MCP (Model Context Protocol) 是一个开放协议，让 AI 助手能够直接调用外部工具和数据源。

1.2 核心价值

在没有 MCP 之前：

用户 → AI → "帮我获取测试用例"
              ↓
        AI 只能说：请运行命令 `npx ts-node index.ts fetch`
              ↓
        用户手动执行命令
              ↓
        用户把结果粘贴给 AI
              ↓
        AI 分析结果

有了 MCP 之后：

用户 → AI → "帮我获取测试用例"
              ↓
        AI 直接调用 MCP 工具 fetch_test_cases()
              ↓
        MCP Server 执行操作，返回结构化数据
              ↓
        AI 直接拿到结果，继续处理

1.3 架构图

┌─────────────┐     MCP 协议      ┌─────────────┐
│  AI 编辑器   │ ←──────────────→ │ MCP Server  │
│ (Cursor等)  │   JSON-RPC 通信   │ (你的工具)   │
└─────────────┘                   └─────────────┘
       │                                 │
       │  调用工具                        │  执行操作
       ↓                                 ↓
  "fetch_test_cases"              读取文件/调用API
                                         │
                                         ↓
                                    返回结果

1.4 核心组件

1.5 代码示例

MCP Server 定义工具：

// mcp-server.ts
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'fetch_test_cases',
        description: '从后端接口获取测试用例',
        inputSchema: {
          type: 'object',
          properties: {
            use_mock: { type: 'boolean' }
          }
        }
      }
    ]
  }
})

AI 直接调用：

// AI 自动调用，无需用户干预
fetch_test_cases({ use_mock: true })

// 返回结构化数据
{
  "success": true,
  "data": [...],
  "total": 5
}

1.6 常见 MCP 工具

二、Rule - 行为约束规则

2.1 什么是 Rule？

Rule 是约束 AI 行为的规则，让 AI 按特定方式和规范工作。

2.2 核心价值

用户请求 ──→ AI 检查 Rule ──→ 按 Rule 约束执行
                    ↓
            "必须先写测试"
            "代码风格要符合 xxx"
            "禁止使用某些 API"

2.3 Rule 类型

2.4 Rule 示例

# 编码规范 Rule

## 代码风格
- 所有函数必须有 JSDoc 注释
- 禁止使用 any 类型
- 变量命名使用 camelCase
- 常量使用 UPPER_SNAKE_CASE

## 安全规则
- 禁止硬编码密钥和敏感信息
- SQL 查询必须参数化
- 用户输入必须校验和转义

## 工作流规则
- 修改代码前先写测试
- 提交前检查 lint 错误
- 重要修改需要代码审查

## 禁止事项
- 不要删除现有注释
- 不要修改 .env 文件
- 不要直接修改 node_modules

2.5 Rule 文件结构

项目根目录/
├── .cursor/
│   └── rules/           # Cursor 规则目录
│       ├── coding.md    # 编码规范
│       ├── security.md  # 安全规范
│       └── workflow.md  # 工作流规范
├── .github/
│   └── copilot-instructions.md  # GitHub Copilot 规则
└── .codebuddy/
    └── rules/           # Codebuddy 规则目录

2.6 Rule 作用范围

三、Skills - 能力技能包

3.1 什么是 Skills？

Skills 是封装好的能力包，包含 Prompt 模板、工具调用和领域知识，让 AI 拥有特定领域的专业能力。

3.2 核心价值

用户请求 ──→ AI 加载 Skill ──→ 使用 Skill 中的能力处理
                    ↓
            Prompt 模板
            工具调用
            领域知识

3.3 Skills 组成要素

3.4 Skills 示例

# Skill: code-review

## 触发条件
用户说"帮我审查代码"或"review this code"时激活

## 执行步骤
1. 读取目标代码文件
2. 执行 lint 检查
3. 执行单元测试
4. 按清单逐项审查：
   - 代码风格
   - 安全问题
   - 性能问题
   - 可维护性
5. 输出分级报告

## 审查清单
### 安全性
- [ ] 无 SQL 注入风险
- [ ] 无 XSS 漏洞
- [ ] 敏感数据已脱敏

### 性能
- [ ] 无 N+1 查询
- [ ] 无内存泄漏风险
- [ ] 算法复杂度合理

### 可维护性
- [ ] 函数职责单一
- [ ] 命名语义清晰
- [ ] 注释恰当

## 输出格式
### Blocker（必须修复）
- 问题 1：描述 + 位置 + 修复建议

### Major（重要问题）
- 问题 1：描述 + 位置 + 修复建议

### Minor（小问题）
- 问题 1：描述 + 位置 + 修复建议

3.5 常见 Skills 类型

四、三者关系与协作

4.1 协作流程图

┌──────────────────────────────────────────────────────────────┐
│                        用户请求                               │
│                    "帮我审查这段代码"                          │
└─────────────────────────┬────────────────────────────────────┘
                          ↓
┌──────────────────────────────────────────────────────────────┐
│  Rule (约束层)                                                │
│  ┌────────────────────────────────────────────────────────┐  │
│  │ • "审查时必须检查安全问题"                                │  │
│  │ • "输出必须按 Blocker/Major/Minor 分级"                  │  │
│  │ • "每个问题必须包含位置和修复建议"                        │  │
│  └────────────────────────────────────────────────────────┘  │
└─────────────────────────┬────────────────────────────────────┘
                          ↓
┌──────────────────────────────────────────────────────────────┐
│  Skill (能力层)                                               │
│  ┌────────────────────────────────────────────────────────┐  │
│  │ 加载 code-review 技能包                                  │  │
│  │ • Prompt: 如何审查代码的指令                             │  │
│  │ • 知识: 常见代码问题清单                                 │  │
│  │ • 步骤: 逐个检查点执行                                   │  │
│  └────────────────────────────────────────────────────────┘  │
└─────────────────────────┬────────────────────────────────────┘
                          ↓
┌──────────────────────────────────────────────────────────────┐
│  MCP (执行层)                                                 │
│  ┌────────────────────────────────────────────────────────┐  │
│  │ 调用工具执行具体操作                                      │  │
│  │ • read_file: 读取代码文件                               │  │
│  │ • read_lints: 获取 lint 错误                            │  │
│  │ • execute_command: 执行测试                             │  │
│  └────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────┘
                          ↓
┌──────────────────────────────────────────────────────────────┐
│                        输出结果                               │
│  • Blocker: 1 个（SQL 注入风险）                              │
│  • Major: 2 个（缺少错误处理）                                 │
│  • Minor: 3 个（命名不规范）                                  │
└──────────────────────────────────────────────────────────────┘

4.2 职责划分

4.3 类比理解

4.4 配合示例

场景：开发一个 Vue 组件

1. Skill: 加载 "Vue 组件开发" 技能包
   - 获取组件模板
   - 获取最佳实践

2. Rule: 应用项目规范
   - 组件命名规范
   - Props 定义规范
   - 样式规范

3. MCP: 执行具体操作
   - read_file: 读取现有组件
   - write_file: 创建新组件
   - execute_command: 运行 lint

五、实际应用场景

5.1 场景一：代码审查

5.2 场景二：API 开发

5.3 场景三：故障排查

5.4 场景四：技术方案设计

六、最佳实践

6.1 MCP 最佳实践

6.2 Rule 最佳实践

6.3 Skills 最佳实践

6.4 组合使用最佳实践

┌─────────────────────────────────────────────────────────────┐
│                     推荐的组合策略                           │
├─────────────────────────────────────────────────────────────┤
│  1. 先定义 Rule，建立规范基础                                │
│  2. 再封装 Skills，沉淀团队能力                              │
│  3. 最后开发 MCP，连接必要系统                               │
│  4. 三者配合，形成完整的 AI 辅助开发体系                      │
└─────────────────────────────────────────────────────────────┘

七、总结

7.1 一句话总结

7.2 协作关系

Skill 决定做什么 → Rule 决定怎么做 → MCP 负责具体执行

7.3 价值体现

7.4 未来展望

随着 AI 编辑器的发展，三大机制将更加成熟：

• MCP：更多标准化工具，更便捷的接入方式
• Rule：更智能的上下文感知，更灵活的约束机制
• Skills：更丰富的技能生态，更精准的场景匹配

掌握这三大机制，将帮助开发者更好地利用 AI 编辑器，提升开发效率和代码质量。

参考资料

• Model Context Protocol (MCP) 官方文档
• Cursor Rules 文档
• GitHub Copilot Instructions