大模型 Skills 技术深度分析

第一章：Skills 技术全景认知

1.1 从 Prompt 工程到 Skills 工程的演进

                   AI 应用能力的三层演进                                
                                                                      
  2023: Prompt Engineering (提示词工程)                                 
    → "告诉 AI 怎么做"                                                 
    → 单次对话内有效，无法复用，无法标准化                                
    → 本质: 人→AI 的自然语言指令                                        
                                                                      
  2024: Context Engineering (上下文工程)                                
    → "给 AI 看什么"                                                   
    → RAG、MCP、System Prompt 管理                                     
    → 本质: 管理 AI 的信息输入窗口                                      
                                                                      
  2025-2026: Skills Engineering (技能工程) ← 当前阶段                   
    → "教会 AI 怎么做一类事"                                            
    → 可复用、可分发、可组合、可版本化                                    
    → 本质: 将领域专业知识封装为 AI 可动态加载的标准化能力包              
                                                                      
  核心跃迁:                                                            
  Prompt → 从"对话交互"到"任务执行"                                     
  Context → 从"信息输入"到"能力注入"                                    
  Skills → 从"单次使用"到"可复用资产"                                   

1.2 Skills 的正式定义

Skills 是结构化的专业知识包，将工作流程、最佳实践、脚本和参考文档封装为智能体可访问和应用的标准化格式。 --- Anthropic 官方

一句话理解：Skills 是写给 AI 的"岗位 SOP"------不是给人看的操作手册，而是 AI 可直接解析执行的结构化指令包。

1.3 Skills 的技术演进时间线

2025.10.16  Anthropic 正式发布 Claude Skills 功能
2025.12.18  Agent Skills 发布为开放标准
2026.01     Codex、Cursor、Opencode 等主流 AI 编程工具跟进支持
2026.02     GitHub Copilot、微软 Azure 宣布支持 Skills 标准
2026.Q1     A2A 通信协议 + MCP 工具协议 + Skills 形成三位一体
2026.Q2     Skills 成为 AI Agent 能力分发的主流范式
2026.06     全球公开可用 Skills 超过 6 万个
2026.07     Anthropic 官方 Skills 仓库突破 18 万 GitHub Star

---

第二章：Skills 的核心架构与运行原理

2.1 标准文件结构

每个 Skill 是一个独立目录，遵循 Agent Skills 开放标准（agentskills.io）：

.claude/skills/
└── my-skill-name/              # 技能目录
    ├── SKILL.md                # ★ 核心文件：指令 + 元数据
    ├── scripts/                # 可执行脚本（Python/Shell/JS）
    │   ├── validate.py         # 验证脚本
    │   └── execute.sh          # 执行脚本
    ├── references/             # 参考文档（供 AI 查阅）
    │   ├── api-spec.md         # API 规范
    │   └── style-guide.md      # 风格指南
    └── assets/                 # 资源文件（模板、示例）
        ├── template.json       # 输出模板
        └── examples/           # 示例文件

2.2 SKILL.md 的标准格式

---
name: contract-reviewer
description: "审查合同条款，识别风险点，生成合规建议报告"
version: 1.2.0
author: legal-team
triggers:
  - "审查合同"
  - "合同风险"
  - "合规检查"
tools:
  - name: read_file
  - name: search_database
  - name: write_report
---

# 合同审查技能

## 触发条件
当用户要求审查合同、评估法律风险或进行合规检查时激活此技能。

## 执行步骤

### Step 1: 合同结构识别
- 识别合同类型（劳动合同/采购合同/服务协议/保密协议）
- 提取关键条款：标的、价格、期限、违约责任、争议解决
- 检查必备条款是否完整

### Step 2: 风险扫描
- 逐条检查以下风险维度：
  - [ ] 违约责任是否对等
  - [ ] 知识产权归属是否明确
  - [ ] 保密条款是否充分
  - [ ] 争议解决机制是否可执行
  - [ ] 终止条款是否合理

### Step 3: 合规对标
- 对照《合同法》第 XX 条验证
- 参照 `references/compliance-checklist.md` 逐项检查

### Step 4: 生成报告
- 使用 `assets/template.json` 中的报告模板
- 输出格式严格遵循模板结构

## 约束条件
- 仅基于提供的合同文本和法律条文分析，不编造法律依据
- 不确定的法律问题标注为"需人工确认"
- 不替代专业律师意见

2.3 核心机制：渐进式披露（Progressive Disclosure）

这是 Skills 最核心的架构创新，解决了"Agent 需要十八般武艺，但上下文窗口有限"的根本矛盾：

┌──────────────────────────────────────────────────────────────────────┐
│              渐进式披露三层架构 (Progressive Disclosure)                │
│                                                                      │
│  L1 元数据层 --- 始终加载                                                 │
│  ┌────────────────────────────────────────────────────┐              │
│  │  每个 Skill 的 name + description (约 100 tokens)   │              │
│  │  Agent 启动时，将所有已安装 Skill 的元数据注入          │              │
│  │  System Prompt                                     │              │
│  │                                                    │              │
│  │  示例: "contract-reviewer: 审查合同条款，识别风险点"   │              │
│  │  → Agent 知道"我有这个能力"，但不知道具体怎么做         │              │
│  └────────────────────────────────────────────────────┘              │
│                          ↓ 命中触发条件                                │
│  L2 指令层 --- 按需加载                                                  │
│  ┌────────────────────────────────────────────────────┐              │
│  │  SKILL.md 的完整正文（执行步骤、约束条件等）            │              │
│  │  当 Agent 判断当前任务匹配某个 Skill 时才加载          │              │
│  │  约 500-3000 tokens                                │              │
│  │                                                    │              │
│  │  → Agent 知道"具体怎么做"，但还没有参考资源             │              │
│  └────────────────────────────────────────────────────┘              │
│                          ↓ 正文指示需要                                │
│  L3 资源层 --- 按需加载                                                  │
│  ┌────────────────────────────────────────────────────┐              │
│  │  references/、scripts/、assets/ 中的具体内容         │              │
│  │  当 SKILL.md 中的步骤指示需要参考资源时才加载           │              │
│  │  可达数千 tokens                                    │              │
│  │                                                    │              │
│  │  → Agent 获得"完整的执行上下文和工具"                  │              │
│  └────────────────────────────────────────────────────┘              │
└──────────────────────────────────────────────────────────────────────┘

关键数据：

指标	无 Skills（全量 System Prompt）	有 Skills（渐进式披露）	优化幅度
Token 消耗	每次 30-50K tokens	每次 3-8K tokens	降低 60-80%
指令遵循准确率	65-75%	85-95%	提升 15-25%
30 个 Skill 的元数据开销	30×2000=60K tokens	30×100=3K tokens	降低 95%

2.4 渐进式披露 vs 懒加载：本质区别

懒加载 (Lazy Loading):
  → 时间维度的延迟：东西先不加载，用到再加载
  → 加载的东西本身没变，只是加载时机变了
  → 仍然是"把整本手册给 AI"

渐进式披露 (Progressive Disclosure):
  → 架构维度的信息分级：把知识加载切成三个清晰的层级
  → 每一层只加载当前阶段需要的信息量
  → L1 只给"目录"，L2 给"操作步骤"，L3 给"参考手册"
  → 信息是分级组织的，不是简单的延迟加载

2.5 Skills 的完整运行流程

┌─────────────────────────────────────────────────────────────────┐
│                    Skills 完整运行时序                            │
│                                                                 │
│  1. Agent 启动                                                   │
│     → 扫描 .claude/skills/ 目录                                  │
│     → 加载所有 SKILL.md 的 YAML frontmatter (name+description)   │
│     → 注入 System Prompt: "你有以下技能可用: [列表]"               │
│                                                                 │
│  2. 用户输入                                                     │
│     → "帮我审查这份采购合同"                                       │
│                                                                 │
│  3. Skill 路由（语义匹配）                                        │
│     → Agent 根据 name+description 判断应激活哪个 Skill            │
│     → 匹配到 "contract-reviewer"                                 │
│                                                                 │
│  4. L2 加载（指令注入）                                           │
│     → 读取 contract-reviewer/SKILL.md 的完整正文                  │
│     → 注入到当前上下文                                            │
│                                                                 │
│  5. L3 加载（资源注入）                                           │
│     → 根据正文中的步骤指示，按需加载:                               │
│       - references/compliance-checklist.md                      │
│       - assets/template.json                                    │
│     → 调用 scripts/validate.py（通过 Function Calling）           │
│                                                                 │
│  6. 执行与输出                                                   │
│     → 严格遵循 SKILL.md 中的步骤和约束                             │
│     → 使用模板格式化输出                                          │
│     → 引用参考文档中的具体条款                                     │
│                                                                 │
│  7. 会话结束                                                     │
│     → L2/L3 内容从上下文中移除                                     │
│     → 仅保留 L1 元数据，为下次请求准备                              │
└─────────────────────────────────────────────────────────────────┘

---

第三章：Skills 与 MCP、Function Calling 的关系

3.1 三层基础设施的定位

┌──────────────────────────────────────────────────────────────────┐
│           Agent 工程的三大基础设施                                  │
│                                                                  │
│  ┌──────────────────────────────────────────────────────────┐    │
│  │  Function Calling (执行层)                                │    │
│  │  "让 AI 调用一个函数"                                      │    │
│  │  → API 级工具调用协议                                      │    │
│  │  → 模型判断需要调用 → 返回函数名+参数 → 开发者执行             │    │
│  │  → 粒度: 单次函数调用                                      │    │
│  └──────────────────────────────────────────────────────────┘    │
│                          ↑ 底层能力                               │
│  ┌──────────────────────────────────────────────────────────┐    │
│  │  MCP --- Model Context Protocol (连接层)                    │    │
│  │  "让 AI 连接一套外部能力"                                   │    │
│  │  → 标准化工具/资源服务器协议                                 │    │
│  │  → 数据库、代码图谱、浏览器、GitHub、内部系统                  │    │
│  │  → 粒度: 一组相关工具的标准化连接                             │    │
│  └──────────────────────────────────────────────────────────┘    │
│                          ↑ 能力桥接                               │
│  ┌──────────────────────────────────────────────────────────┐    │
│  │  Skills (知识层)                                          │    │
│  │  "教会 Agent 怎么做一类事"                                  │    │
│  │  → 指令+资源+脚本的工作流包                                  │    │
│  │  → 可复用任务流程、团队规范、领域操作手册                      │    │
│  │  → 粒度: 完整的任务流程                                     │    │
│  └──────────────────────────────────────────────────────────┘    │
└──────────────────────────────────────────────────────────────────┘

3.2 核心差异对比

维度	Function Calling	MCP	Skills
解决什么	让模型调用定义的函数	让模型连接外部系统	让模型学会一套流程
本质	执行协议	连接协议	知识封装
类比	手（执行动作）	桥（连接世界）	脑（掌握方法）
抽象层级	API 级	服务级	流程级
可复用性	低（函数级）	中（工具组级）	高（流程级）
人可读性	低（代码）	中（JSON Schema）	高（Markdown）
创建门槛	需要编码	需要编码	仅需写文档
分发方式	代码仓库	MCP Server	Skills 市场
跨模型	模型相关	通用	通用
与 Prompt 的关系	独立	独立	封装 Prompt

3.3 三者的协同关系

Skills 不是替代 MCP 和 Function Calling，而是基于它们构建：

  Skill (合同审查)
    ├── SKILL.md (指令: "Step 3: 查询历史合同")
    │     ↓ 调用
    ├── MCP Server (PostgreSQL) ← 连接合同数据库
    │     ↓ 使用
    └── Function Calling (read_file) ← 执行文件读取

  运行时:
    1. Skill 决定"做什么" → 查询历史合同
    2. MCP 提供"连接什么" → 连接 PostgreSQL
    3. Function Calling 执行"具体动作" → 调用 read_file

3.4 Skills 与 MCP 的"替代战争"真相

Agent Skills 与 MCP 并非对手，而是搭档。前者回答"怎么做才对"，后者解决"能不能做"。一个由产品经理和业务专家驱动，一个由工程师和 SRE 构建。

Skills: 声明式知识 → "审查合同应该遵循什么流程"
MCP: 命令式能力 → "如何连接到合同管理系统"

两者互补:
  有 Skills 无 MCP → Agent 知道怎么做，但无法连接外部系统
  有 MCP 无 Skills → Agent 能连接外部系统，但不知道正确的流程
  两者兼有 → Agent 既知道怎么做，又能执行

---

第四章：框架支持与实现方案

4.1 主流框架对 Skills 的支持情况

框架/平台	Skills 支持方式	原生程度	适合场景	中文支持
Claude Code	SKILL.md 原生支持	★★★★★ 原生创建者	编程/开发	★★★
Cursor	.cursor/skills/ 目录	★★★★	IDE 集成开发	★★★
Coze 2.0	技能中心 + 自然语言创建	★★★★	非技术用户	★★★★★
OpenClaw	skills install 命令	★★★★	开源 Agent	★★★
Dify	工作流 + 插件体系	★★★ 可模拟	企业应用	★★★★★
AgentScope	Agent Skills API	★★★	Python 开发	★★★★
LangChain/LangGraph	Tool + Prompt 模板组合	★★ 需自建	灵活定制	★★★

4.2 Claude Code：Skills 的原生实现

# 安装 Skills
claude skills install contract-reviewer

# 创建自定义 Skill
claude skills create my-skill

# 查看已安装 Skills
claude skills list

# Skills 目录结构
~/.claude/skills/
├── contract-reviewer/
│   ├── SKILL.md
│   └── references/
├── code-reviewer/
│   ├── SKILL.md
│   └── scripts/
└── data-analyst/
    ├── SKILL.md
    └── assets/

运行原理：

Claude Code 内部实现:

1. 启动时:
   skill_registry = scan_skills_directory()
   system_prompt += format_skill_metadata(skill_registry)
   # 注入: "你有以下技能: contract-reviewer(审查合同), code-reviewer(代码审查)..."

2. 每轮对话:
   user_intent = analyze_user_input(user_message)
   matched_skill = semantic_match(user_intent, skill_registry)
   
   if matched_skill:
       skill_content = load_skill_full(matched_skill)  # L2+L3 加载
       context.inject(skill_content)
   
3. 执行中:
   if skill_references_tools:
       tool_calls = model.generate_tool_calls()
       for call in tool_calls:
           result = execute_tool(call)  # 通过 Function Calling
           context.append(result)

4.3 Coze 2.0：面向非技术用户的 Skills 实现

Coze 2.0 的 Skills 中心:

特点:
  1. 自然语言创建: 用中文描述需求，AI 自动生成 SKILL.md
  2. 可视化编辑: 拖拽式编辑技能步骤
  3. 技能市场: 一键安装他人分享的技能
  4. 多端分发: 技能可部署到飞书/微信/钉钉

创建流程:
  1. 进入 coze.cn/skills
  2. 点击"创建技能"
  3. 输入描述: "帮我每天早上总结科技新闻"
  4. AI 自动生成技能框架
  5. 用户微调后保存

优势: 零代码门槛，中文生态最友好
局限: 闭源，自定义能力有限

4.4 Dify：用工作流 + 插件模拟 Skills

Dify 实现 Skills 的方案:

  方案1: 工作流模板
    → 将 Skill 的执行步骤建模为 Dify 工作流
    → 每个节点对应 SKILL.md 中的一个步骤
    → 通过 API 触发，模拟 Skill 的按需加载

  方案2: 插件体系
    → 将 Skill 封装为 Dify 插件
    → 包含: description (L1) + instructions (L2) + tools (L3)
    → 支持 Marketplace 分发

  方案3: Prompt 模板 + 变量注入
    → 将 SKILL.md 的内容作为 System Prompt 模板
    → 根据用户意图动态注入对应的 Prompt 模板
    → 最简单但最接近 Skills 原理的实现

  推荐方案:
    → 简单场景: 方案3 (Prompt 模板)
    → 中等场景: 方案1 (工作流模板)
    → 复杂场景: 方案2 (插件体系)

4.5 AgentScope：阿里达摩院的 Skills 实现

# AgentScope 的 Skills API 实现
import agentscope
from agentscope.skills import Skill, SkillRegistry

# 定义 Skill
class ContractReviewSkill(Skill):
    name = "contract-reviewer"
    description = "审查合同条款，识别风险点，生成合规建议报告"
    
    def execute(self, contract_text: str) -> dict:
        # Step 1: 结构识别
        structure = self._identify_structure(contract_text)
        
        # Step 2: 风险扫描
        risks = self._scan_risks(contract_text, structure)
        
        # Step 3: 合规对标
        compliance = self._check_compliance(contract_text)
        
        # Step 4: 生成报告
        report = self._generate_report(risks, compliance)
        return report

# 注册到 Agent
agent = agentscope.Agent(
    model="qwen3-max",
    skills=[ContractReviewSkill()]
)

# Agent 自动根据用户意图选择并执行 Skill
response = agent("帮我审查这份采购合同")

4.6 自研 Skills 框架的参考架构

class SkillsFramework:
    """企业自研 Skills 框架的参考实现"""
    
    def __init__(self, skills_dir=".skills/"):
        self.skills_dir = skills_dir
        self.registry = {}  # L1 元数据缓存
        self._load_metadata()
    
    def _load_metadata(self):
        """L1: 加载所有 Skill 的元数据"""
        for skill_dir in Path(self.skills_dir).iterdir():
            skill_md = skill_dir / "SKILL.md"
            if skill_md.exists():
                metadata = self._parse_frontmatter(skill_md)
                self.registry[metadata["name"]] = {
                    "path": skill_dir,
                    "description": metadata["description"],
                    "triggers": metadata.get("triggers", [])
                }
    
    def get_system_prompt_extension(self) -> str:
        """生成 L1 级别的 System Prompt 扩展"""
        skills_list = "\n".join(
            f"- {name}: {info['description']}" 
            for name, info in self.registry.items()
        )
        return f"你有以下技能可用:\n{skills_list}\n请根据用户需求判断是否需要使用某个技能。"
    
    def match_skill(self, user_input: str) -> Optional[str]:
        """语义匹配: 判断用户意图是否命中某个 Skill"""
        # 方案1: 关键词匹配 (triggers)
        for name, info in self.registry.items():
            for trigger in info["triggers"]:
                if trigger in user_input:
                    return name
        
        # 方案2: Embedding 相似度匹配
        # user_embedding = embed(user_input)
        # skill_embeddings = [embed(info["description"]) for info in self.registry.values()]
        # best_match = cosine_similarity(user_embedding, skill_embeddings)
        # return best_match if best_match > threshold else None
        
        return None
    
    def load_skill(self, skill_name: str) -> str:
        """L2: 加载完整指令"""
        skill_path = self.registry[skill_name]["path"]
        return (skill_path / "SKILL.md").read_text()
    
    def load_resource(self, skill_name: str, resource_path: str) -> str:
        """L3: 加载资源文件"""
        skill_path = self.registry[skill_name]["path"]
        return (skill_path / resource_path).read_text()
    
    def execute(self, user_input: str, llm_client) -> str:
        """完整执行流程"""
        # 1. 匹配 Skill
        matched = self.match_skill(user_input)
        if not matched:
            return llm_client.chat(user_input)  # 无 Skill，正常对话
        
        # 2. L2 加载
        skill_instructions = self.load_skill(matched)
        
        # 3. 构建增强 Prompt
        enhanced_prompt = f"{skill_instructions}\n\n用户请求: {user_input}"
        
        # 4. 调用 LLM
        response = llm_client.chat(enhanced_prompt)
        
        # 5. L3 按需加载 (如果 LLM 请求参考资源)
        # ... 根据 response 中的工具调用决定
        
        return response

---

第五章：Skills 的四种设计模式

5.1 模板模式

解决问题: 输出格式漂移

  没有 Skill 时:
    用户: "写一份合同审查报告"
    AI: 输出格式每次都不一样，有时是表格，有时是段落，有时遗漏关键项

  有 Skill 时:
    SKILL.md 中定义: "输出必须使用 assets/template.json 中的格式"
    → 每次输出格式完全一致
    → 格式遵循率从 40-60% 提升到 95%+

5.2 脚本增强模式

解决问题: LLM 计算不精确 / 需要确定性操作

  SKILL.md 中:
    "Step 3: 运行 scripts/validate.py 验证数据准确性"
    "Step 5: 使用 scripts/calculate.py 执行精确计算"

  原理:
    LLM 不擅长精确计算 → 用脚本替代
    LLM 不擅长确定性操作 → 用脚本保证
    LLM 只负责"决策"和"理解"，脚本负责"执行"

5.3 知识分层模式

解决问题: 上下文窗口有限，参考资料太多

  references/
    ├── basic-guide.md        (500 tokens, 常用)
    ├── advanced-reference.md  (5000 tokens, 深入)
    └── edge-cases.md          (10000 tokens, 罕见)

  SKILL.md 中:
    "默认使用 basic-guide.md"
    "如果用户要求深入分析，加载 advanced-reference.md"
    "如果遇到罕见场景，加载 edge-cases.md"

  效果: 80% 的请求只加载 500 tokens，不浪费上下文窗口

5.4 最小权限模式

解决问题: Agent 越权操作

  SKILL.md 中明确约束:
    "只能读取数据库，不能写入"
    "只能查询，不能修改"
    "遇到不确定的操作，必须请求人工确认"

  原理:
    类似操作系统的权限控制
    每个 Skill 只声明它需要的最小工具集
    不在 Skill 工具列表中的工具，Agent 不应调用

---

第六章：Skills 分发生态与优质社区

6.1 Skills 分发渠道全景

渠道	类型	网址	Skills 数量	特点
Anthropic 官方仓库	GitHub	github.com/anthropic/skills	50+	官方认证，质量最高
skills.sh	社区市场	skills.sh	500+	最早的市场，安装量最高 37K+
SkillHub	商业市场	skillhub.cloud.tencent.com	200+	腾讯出品，中文优化，内容签名
SkillsMP	社区聚合	skillsmp.com	72+ 精选	自动抓取 GitHub，分类浏览
Coze 技能中心	平台内	coze.cn/skills	1000+	扣子 2.0 内置，零代码
GitHub 搜索	开源	github.com/topics/agent-skills	60000+	最全，但需筛选质量
PM Skills Marketplace	垂直领域	github.com/pawelhryn/...	68 Skill	产品经理专用，21K+ Star

6.2 TOP 20 热门 Skills（综合热度排名）

排名	Skill 名称	分类	安装量	Star	功能
1	skill-creator	元技能	48K+	18W	用 AI 创建新 Skill（Skills 生态基石）
2	universal-code-reviewer	编程	37K+	15K	全语言代码审查
3	marketing-skills	营销	28K+	22K	GTM/SEO/CRO 全链路营销
4	pm-skills	产品	25K+	21K	产品经理全生命周期 68 个 Skill
5	grill-me	编程	22K+	18W	需求拷问（防止模糊需求）
6	tdd-skill	编程	20K+	18W	TDD 测试驱动开发
7	article-copilot	写作	18K+	8K	素材清洗→逻辑梳理→正文写作
8	data-analyst	数据	15K+	6K	SQL 生成→数据分析→可视化
9	bug-diagnoser	编程	14K+	18W	Bug 诊断与修复
10	token-optimizer	优化	13K+	5K	Token 消耗优化（立省 97%）
11	legal-reviewer	法律	12K+	4K	合同审查与合规检查
12	api-designer	编程	11K+	7K	RESTful API 设计规范
13	startup-skills	创业	10K+	5K	创业方法论（最小可行创业者）
14	security-scanner	安全	9K+	3K	安全漏洞扫描与修复
15	doc-writer	写作	8K+	4K	技术文档自动生成
16	architecture-reviewer	编程	7K+	3K	代码架构评审与改进
17	hr-resume-screener	人力	6K+	2K	简历筛选与评估
18	financial-analyzer	金融	5K+	2K	财务报表分析
19	project-planner	管理	4K+	2K	大项目规划与拆解
20	ctf-skills	安全	3K+	1K	CTF 安全竞赛技能包

6.3 高质量 Skills 的识别标准

优质 Skill 的 5 个标志:

  1. 元数据完整
     → name, description, version, author, triggers 齐全
     → description 精确到一句话，不模糊

  2. 渐进式披露设计合理
     → SKILL.md 正文 ≤ 3000 tokens
     → 详细内容放在 references/ 中按需加载
     → 不是把所有内容塞进一个文件

  3. 有可执行脚本
     → scripts/ 目录下有实际可运行的脚本
     → 不是纯文本指令，而是有确定性执行能力

  4. 有输出模板
     → assets/ 目录下有模板文件
     → 格式约束明确，输出可预测

  5. 有约束条件
     → 明确标注"不能做什么"
     → 最小权限设计
     → 不确定时标注"需人工确认"

---

第七章：常见应用场景与效果评估

7.1 企业内部应用场景分类

场景	典型 Skill	价值	难度
代码审查	code-reviewer	规范一致性↑，Bug 率↓	★★
合同审查	legal-reviewer	风险识别率↑，合规性↑	★★★
文档生成	doc-writer	格式一致性↑，效率↑	★★
数据分析	data-analyst	SQL 准确率↑，分析深度↑	★★★
HR 简历筛选	hr-resume-screener	效率↑，公平性↑	★★
客服 SOP	customer-service	幻觉率↓，一致性↑	★
财务分析	financial-analyzer	准确率↑，报告速度↑	★★★★
安全审计	security-scanner	漏洞发现率↑	★★★★
项目管理	project-planner	计划合理性↑	★★
营销文案	marketing-skills	转化率↑，品牌一致性↑	★★

7.2 效果提升评估数据

7.2.1 代码审查场景

指标	无 Skill	有 Skill	提升幅度
审查规范一致性	45%	92%	+104%
关键 Bug 发现率	60%	85%	+42%
审查报告格式一致性	30%	95%	+217%
每次审查 Token 消耗	8K	3K	-63%
误报率	25%	8%	-68%

7.2.2 合同审查场景

指标	无 Skill	有 Skill	提升幅度
风险条款识别率	55%	88%	+60%
法律条文引用准确率	40%	82%	+105%
输出格式合规率	35%	94%	+169%
幻觉率（编造法律条文）	15%	2%	-87%
报告生成时间	15 min	3 min	-80%

7.2.3 数据分析场景

指标	无 Skill	有 Skill	提升幅度
SQL 生成准确率	60%	85%	+42%
分析报告格式一致性	40%	90%	+125%
不确定时的标注率	10%	75%	+650%
Token 消耗	12K/次	5K/次	-58%

7.2.4 TRS 框架：推理模型的 Skills 加速

清华&北大&奇元科技提出的 TRS（Thinking with Reasoning Skills）框架：

指标	无 Skills	TRS 框架	提升幅度
数学推理准确率	基线	+3.2%	不降反升
编程推理准确率	基线	+2.8%	不降反升
Token 消耗	基线	-6%~59%	大幅降低
推理延迟	基线	-20%~50%	大幅降低

核心洞察：通过将历史推理轨迹蒸馏成可复用的"技能卡片"，在推理时检索注入，实现了"更少 Token，更高准确率"的反直觉突破。

7.3 Skills 的核心价值量化

Skills 对大模型应用的四大核心价值:

1. 幻觉率降低: 60-87%
   → 约束条件明确，"不能做什么"写死在 SKILL.md
   → 不确定时标注"需人工确认"，而非编造

2. 输出格式一致性: 提升 125-217%
   → 模板约束，输出格式可预测
   → 批量处理时，结果可对比、可汇总

3. Token 消耗降低: 58-97%
   → 渐进式披露避免无效 Token
   → Prompt Caching 命中率提升
   → 避免重复的"从零思考"

4. 领域适配效率: 提升 10-50x
   → 不需要微调，一个 SKILL.md 即可适配新领域
   → 非技术人员也可创建和维护
   → 可分发、可复用、可版本化

---

第八章：Skills 与 Workflow 的对比

8.1 架构哲学差异

Workflow (Dify/Coze/N8N):
  → 确定性编排: 固定节点 → 固定流程 → 固定输出
  → 适合: 流程明确、步骤固定的场景
  → 类比: 流水线

Skills:
  → 声明式指导: 提供方法 → Agent 自主决策 → 灵活输出
  → 适合: 流程灵活、需要判断力的场景
  → 类比: 岗位 SOP

关键区别:
  Workflow: "先做A，再做B，然后做C" (硬编码)
  Skill:    "审查合同时，应该关注这些风险点" (指导性)

8.2 具体场景对比：HR 简历筛选

维度	Workflow (Dify)	Skills (Claude Code)
实现方式	拖拽节点编排	写 SKILL.md
灵活性	低（固定流程）	高（Agent 自主判断）
创建时间	1-2 小时	15-30 分钟
异常处理	需要预设分支	Agent 自主处理
可维护性	可视化，直观	文本，版本可控
可分发性	平台内	跨平台
适合团队	运营/业务	技术/产品

8.3 选择建议

选 Workflow 的场景:
  ✗ 流程完全固定，不需要 Agent 判断
  ✗ 每一步的输入输出明确
  ✗ 需要可视化监控和调试
  ✗ 团队以非技术人员为主

选 Skills 的场景:
  ✗ 流程需要灵活判断
  ✗ 需要跨平台、跨模型复用
  ✗ 需要频繁迭代和版本管理
  ✗ 需要社区分发和协作

选 Workflow + Skills 的场景:
  ✗ 复杂场景: Workflow 做宏观编排，Skills 做微观指导
  ✗ 例如: Dify 工作流中调用 Agent，Agent 配备 Skills

---

第九章：Skills 的企业落地实践

9.1 企业 Skills 架构分层设计

┌──────────────────────────────────────────────────────────────────┐
│                 企业 Skills 分层架构                               │
│                                                                  │
│  Layer 1: 个人 Skills (个人效率)                                  │
│  ~/.skills/                                                      │
│  → 个人偏好、工作习惯、常用模板                                    │
│  → 不共享，不版本化                                                │
│                                                                  │
│  Layer 2: 项目 Skills (团队协作)                                  │
│  .skills/ (项目根目录)                                            │
│  → 项目规范、技术栈、代码风格                                      │
│  → Git 管理，团队共享                                              │
│                                                                  │
│  Layer 3: 组织 Skills (企业资产)                                  │
│  enterprise-skills/ (内部仓库)                                    │
│  → 合规要求、审批流程、品牌规范                                     │
│  → 内部市场分发，版本管理，审计日志                                  │
│                                                                  │
│  覆盖关系: L3 > L2 > L1                                          │
│  → 组织 Skills 优先于项目 Skills                                   │
│  → 项目 Skills 优先于个人 Skills                                   │
└──────────────────────────────────────────────────────────────────┘

9.2 企业 Skills 的 Token 优化策略

策略 1: 渐进式披露 (基础)
  → L1 元数据 < 100 tokens/Skill
  → L2 指令 < 3000 tokens/Skill
  → L3 资源按需加载

策略 2: Prompt Caching (进阶)
  → SKILL.md 内容在多轮对话中缓存
  → Anthropic 缓存机制: 重复轮次 Token 消耗降低 90%
  → 将高频 Skill 的 System Prompt 设为缓存前缀

策略 3: 智能上下文裁剪 (高级)
  → 自动识别无关上下文并裁剪
  → 保留核心信息，移除冗余
  → Token 消耗再降低 50%

策略 4: 语义路由替代模型思考 (极致)
  → 不让 LLM 判断"用哪个 Skill"
  → 用 Embedding 相似度做确定性路由
  → 将"模型思考"变成"基础设施"
  → 节省路由判断的 Token 消耗

综合效果:
  无优化: 30-50K tokens/次
  仅策略1: 8-15K tokens/次 (-70%)
  策略1+2: 3-8K tokens/次 (-85%)
  策略1+2+3: 1-5K tokens/次 (-93%)
  全部策略: 0.5-3K tokens/次 (-97%)

9.3 企业 Skills 的治理与安全

治理要点:

1. 版本管理
   → 每个 Skill 有版本号
   → 变更需要审批
   → 支持回滚

2. 内容签名
   → SkillHub 的签名机制
   → 验证 Skill 内容是否被篡改
   → 防止供应链攻击

3. 权限控制
   → 最小权限原则
   → 每个 Skill 只声明需要的工具
   → 敏感操作需要人工确认

4. 审计日志
   → 记录每次 Skill 的加载和执行
   → 记录输入输出
   → 可追溯

5. 质量评估
   → 定期评估 Skill 的触发准确率
   → 评估输出质量
   → 评估 Token 消耗效率
   → 淘汰低效 Skill

---

第十章：总结与行动建议

10.1 核心结论

Skills 是 2026 年 AI 应用从"对话交互"到"任务执行"的关键基础设施。它不是又一个概念泡沫，而是将大模型从"高分低能实习生"变成"可靠数字员工"的工程化手段。

10.2 行动建议

第一步: 体验 (1 周)
  → 安装 Claude Code 或 Cursor
  → 从 skills.sh 安装 3-5 个热门 Skill
  → 用真实工作场景测试效果

第二步: 创建 (2 周)
  → 选择你最熟悉的领域
  → 用 skill-creator 创建第一个自定义 Skill
  → 遵循渐进式披露原则，保持 SKILL.md < 3000 tokens

第三步: 团队化 (1 个月)
  → 建立项目级 .skills/ 目录
  → 将团队最佳实践封装为 Skills
  → Git 管理，团队共享

第四步: 企业化 (2-3 个月)
  → 建立企业级 Skills 仓库
  → 建立内部 Skills 市场
  → 实施治理与安全策略
  → 评估 Token 消耗优化效果

10.3 一句话总结

Anthropic 核心工程师 Barry Zhang 说的"别造 Agent 了，造 Skills 就行"------这不是否定 Agent，而是指出：未来的竞争将从"谁拥有更强的模型"转向"谁拥有更丰富、更专业的 Skills 生态"。开发者角色从"写代码的人"变为"能力架构师"。Skills 不是终点，而是 AI 应用工程化的起点。