在第一部分,我们建立了对 Agent Skills 的整体认知。现在,我们需要深入理解:Agent 是如何判断要不要调用 Skill 的?整个调用流程是怎样的?这部分的目标是让你理解 Skill 的调用机制,能够判断哪些任务适合使用 Skill。
10.1 Agent 如何判断调用 Skill
当用户发出一个请求时,Agent 需要经历一个完整的决策流程,才能决定是否调用 Skill。这个流程可以分为五个步骤。
首先是识别任务。Agent 需要理解用户的请求是什么类型的任务。比如"帮我补充单元测试"会被识别为测试相关任务,"整理这些 Markdown 文档"会被识别为文档处理任务,"找一个处理 PDF 的 Skill"会被识别为 Skill 搜索任务。
接着是判断能力边界。Agent 需要判断这个任务是否需要 Skill。判断依据包括:任务是否需要结构化流程、是否需要多步骤执行、是否有明确的验证标准。如果任务很简单(如"什么是 Python"),Agent 可以直接回答,不需要调用 Skill。
第三步是匹配 Skill。如果判断需要 Skill,Agent 会在可用的 Skill 列表中查找匹配的 Skill。匹配依据包括:Skill 的 description 是否与任务相关、Skill 的触发条件是否满足、Skill 的能力边界是否覆盖任务需求。
第四步是执行 Skill。匹配到 Skill 后,Agent 会调用 Skill 并传入上下文信息。Skill 内部会引导 Agent 完成任务。
最后是整合输出。Skill 执行完成后,Agent 会将 Skill 的输出整合到对话中,返回给用户。
让我们通过一个具体例子来理解这个流程:
示例:用户请求"帮我补充单元测试"
步骤一:识别任务 → 任务类型:测试相关 → 任务特征:需要理解代码、设计用例、编写测试
**步骤二:判断能力边界 → 需要结构化流程:是 → 需要多步骤执行:是 → 有明确验证标准:是 → 结论:需要调用 Skill
步骤三:匹配 Skill → 搜索关键词:test, unit test, TDD → 匹配到:test-driven-development → 验证能力边界:是,覆盖测试编写流程
步骤四:执行 Skill → 调用 test-driven-development → 传入上下文:当前代码文件 → Skill 引导:理解代码 → 设计用例 → 编写测试
步骤五:整合输出 → Skill 输出:测试代码 + 覆盖率报告 → Agent 整合:返回给用户
Agent Skills 执行流程的阶段推进
10.1.3 Token 经济学:为什么这种设计如此高效
Agent Skills 的发现机制背后有一个精妙的设计哲学——渐进式信息披露(Progressive Disclosure)。
在系统空闲或处理无关任务时,系统仅仅加载包含数百 Token 的所有技能元数据(名字和描述),以维持技能的全局可见性。一旦识别到特定任务匹配,Agent 才通过内部工具读取完整的 SKILL.md(几千 Token),最后才按需动态加载体积庞大的参考资产(可能高达数万 Token)。
这种极具巧思的压缩与解压机制,使得系统能够在不牺牲局部上下文深度的同时,赋予了单体 Agent 几乎无限的广度和可扩展性。
.center { width: auto; display: table; margin-left: auto; margin-right: auto; }渐进式信息披露的 Token 消耗对比
| 阶段 | 加载内容 | Token 消耗 | 触发条件 |
|---|---|---|---|
| 全局注册 | 所有 Skill 的元数据 | ~100/技能 | 系统启动时 |
| 技能激活 | 完整的 SKILL.md | ~3000 | 匹配到任务 |
| 深度引用 | references/ 中的文档 | ~10000+ | 执行到特定步骤 |
这种设计让 Agent 能够"知道"数百个技能的存在,但只在需要时才"学习"具体的操作细节,极大地优化了系统的资源消耗。
10.2 路由决策的完整流程
在上面的五步流程中,最关键的是"步骤三:匹配 Skill"。这个步骤涉及到 Agent 的路由决策机制。
路由决策的核心是:Agent 如何从多个可用的 Skill 中,选择最合适的那一个?
决策依据包括三个主要方面。首先是语义匹配度,Agent 会评估 Skill 的 description 与用户请求的语义相似度,同时进行关键词匹配(如"test"、"PDF"、"markdown")。其次是能力边界匹配,Agent 会判断 Skill 的能力范围是否覆盖任务需求,以及 Skill 是否有处理类似任务的经验。最后是优先级规则,某些 Skill 可能有更高的优先级,或者被标记为"推荐"。
让我们通过一个综合的"五步执行流与路由过滤漏斗图"来直观理解这个完整的决策机制:
这个过滤式漏斗模型展示了 Agent 如何一步步缩小候选 Skill 的范围,最终淬炼出最合适的那一个送入执行流水线。
10.3 实际案例演示
为了更好地理解路由机制,让我们看三个不同类型的请求,观察 Agent 如何做出不同的决策。
案例一:补充单元测试
用户请求:"帮我给这个函数补充单元测试"
Agent 分析: 任务类型为测试相关,需要 Skill(因为需要结构化流程), 候选 Skill 为 test-driven-development, 匹配度高(description 包含"unit test"), 决策结果是调用 test-driven-development
执行结果: 依次完成理解代码逻辑、设计测试场景、编写测试代码、验证覆盖率
案例二:整理 Markdown 文档
用户请求:"帮我整理这些 Markdown 文档"
Agent 分析: 任务类型为文档处理,需要 Skill(因为需要批量处理), 候选 Skill 可能有多个(文档整理、格式化等), 匹配度需要进一步判断具体需求, 决策结果是可能需要询问用户具体需求
执行结果: 询问用户是格式化、还是提取信息、还是生成目录, 根据用户回答,调用相应 Skill
案例三:找 PDF Skill
用户请求:"帮我找一个处理 PDF 的 Skill"
Agent 分析: 任务类型为 Skill 搜索,需要 Skill(需要搜索生态), 候选 Skill 为 find-skills, 匹配度高(description 包含"find skill"), 决策结果是调用 find-skills
执行结果: 搜索关键词 PDF,找到 pdf Skill, 返回 Skill 描述和使用方式
10.4 任务判断练习
现在轮到你来判断了。能开始区分任务类型,你才算真正进入"理解 Skill"的阶段。
下面是几个真实场景,请判断:这个需求会触发 Skill 吗?如果会,是哪个 Skill?
场景一:补充单元测试
用户请求:"帮我给这个函数补充单元测试"
💭 思考:这个需求会触发 Skill 吗?如果会,是哪个 Skill?
答案:会触发 test-driven-development Skill
推理过程:
这是一个需要结构化流程的任务,需要理解代码逻辑、设计测试用例、编写测试代码,符合 TDD Skill 的触发条件。
场景二:简单问答
用户请求:"什么是 Python?"
💭 思考:这个需求会触发 Skill 吗?
答案:不一定需要 Skill
推理过程:
这是一个简单的知识问答任务,Agent 可以直接回答,不需要结构化流程,不符合 Skill 的触发条件。
场景三:找 PDF Skill
用户请求:"帮我找一个处理 PDF 的 Skill"
💭 思考:这个需求会触发 Skill 吗?如果会,是哪个 Skill?
答案:会触发 find-skills Skill
推理过程:
这是一个 Skill 搜索任务,需要搜索生态、对比功能、给出推荐,符合 find-skills Skill 的触发条件。
场景四:复杂工作流
用户请求:"帮我创建一个新项目,包括初始化 Git、创建目录结构、配置 ESLint"
💭 思考:这个需求会触发 Skill 吗?可能需要几个 Skill?
答案:可能需要多个 Skill 组合
推理过程:
这是一个复杂的工作流任务,可能需要项目初始化 Skill 加上配置管理 Skill,或者使用一个综合的项目脚手架 Skill。
通过这些练习,你应该能够初步判断:哪些任务适合使用 Skill,哪些任务不需要 Skill。
10.5 执行机制的代码实现
在理解了 Agent 的五步决策流程之后,我们需要进一步理解:这个流程在代码层面是如何实现的?Skill 是如何被加载、解析、注入到 Agent 的系统提示词中的?
让我们通过一个简化的 Python 实现来理解这个机制。这个实现展示了 Skill 执行器的核心逻辑,帮助你从"使用者视角"切换到"实现者视角"。
10.5.1 SkillExecutor 类的核心逻辑
首先,我们需要一个 SkillExecutor 类来管理 Skill 的加载、解析和匹配。这个类是整个 Skill 系统的核心。
import os
import yaml
from pathlib import Path
from typing import Dict, List, Optional
class SkillExecutor:
"""Skill 执行器:负责加载、解析和匹配 Skill"""
def __init__(self, skills_dir: str = ".claude/skills"):
"""
初始化 Skill 执行器
Args:
skills_dir: Skill 目录路径
"""
self.skills_dir = Path(skills_dir)
self.skills: Dict[str, Dict] = {}
self.load_all_skills()
def load_all_skills(self):
"""加载所有 Skill"""
if not self.skills_dir.exists():
print(f"Skill 目录不存在: {self.skills_dir}")
return
# 遍历 skills 目录下的所有子目录
for skill_path in self.skills_dir.iterdir():
if skill_path.is_dir():
skill_file = skill_path / "SKILL.md"
if skill_file.exists():
self.load_skill(skill_file)
def load_skill(self, skill_file: Path):
"""
加载单个 Skill
Args:
skill_file: SKILL.md 文件路径
"""
with open(skill_file, 'r', encoding='utf-8') as f:
content = f.read()
# 解析 frontmatter 和 body
frontmatter, body = self.parse_skill_content(content)
if frontmatter and 'name' in frontmatter:
skill_name = frontmatter['name']
self.skills[skill_name] = {
'name': skill_name,
'description': frontmatter.get('description', ''),
'body': body,
'path': skill_file
}
print(f"✅ 加载 Skill: {skill_name}")
def parse_skill_content(self, content: str) -> tuple:
"""
解析 Skill 内容,分离 frontmatter 和 body
Args:
content: SKILL.md 文件内容
Returns:
(frontmatter_dict, body_string)
"""
# 检查是否有 frontmatter(以 --- 开头和结尾)
if not content.startswith('---'):
return None, content
# 分离 frontmatter 和 body
parts = content.split('---', 2)
if len(parts) < 3:
return None, content
# 解析 YAML frontmatter
try:
frontmatter = yaml.safe_load(parts[1])
except yaml.YAMLError as e:
print(f"❌ YAML 解析错误: {e}")
return None, content
body = parts[2].strip()
return frontmatter, body
def match_skill(self, user_request: str) -> Optional[Dict]:
"""
根据用户请求匹配最合适的 Skill
Args:
user_request: 用户请求文本
Returns:
匹配到的 Skill 字典,如果没有匹配则返回 None
"""
# 简化的匹配逻辑:基于关键词匹配
keywords = user_request.lower().split()
best_match = None
best_score = 0
for skill_name, skill_data in self.skills.items():
description = skill_data['description'].lower()
# 计算匹配分数
score = sum(1 for keyword in keywords if keyword in description)
if score > best_score:
best_score = score
best_match = skill_data
if best_match and best_score > 0:
print(f"🎯 匹配到 Skill: {best_match['name']} (匹配分数: {best_score})")
return best_match
print("❌ 未找到匹配的 Skill")
return None
这段代码实现了 Skill 执行器的核心功能。load_all_skills() 方法遍历 Skill 目录,加载所有 SKILL.md 文件;parse_skill_content() 方法解析 frontmatter 和 body,分离元数据和主体内容;match_skill() 方法根据用户请求匹配最合适的 Skill。
这个实现虽然简化了很多细节(比如实际的匹配算法会使用语义相似度而不是简单的关键词匹配),但它展示了 Skill 系统的核心工作原理:加载 → 解析 → 匹配。
10.5.2 Prompt 注入机制的实现
当 Agent 匹配到合适的 Skill 后,需要将 Skill 的内容注入到系统提示词中。这个过程称为"Prompt 注入"。让我们看看这个机制是如何实现的。
class AgentWithSkills:
"""带有 Skill 支持的 Agent"""
def __init__(self, skills_dir: str = ".claude/skills"):
"""
初始化 Agent
Args:
skills_dir: Skill 目录路径
"""
self.skill_executor = SkillExecutor(skills_dir)
self.base_system_prompt = """
你是一个智能助手,可以帮助用户完成各种任务。
你可以调用已加载的 Skill 来完成复杂的工作流。
"""
def build_system_prompt(self, skill: Optional[Dict] = None) -> str:
"""
构建系统提示词
Args:
skill: 要注入的 Skill 字典
Returns:
完整的系统提示词
"""
prompt = self.base_system_prompt
if skill:
# 注入 Skill 的内容
prompt += f"\n\n# 当前激活的 Skill: {skill['name']}\n\n"
prompt += f"## Skill 描述\n{skill['description']}\n\n"
prompt += f"## Skill 执行指南\n{skill['body']}\n\n"
prompt += "请严格按照上述 Skill 的 Workflow 执行任务。\n"
return prompt
def process_request(self, user_request: str) -> str:
"""
处理用户请求
Args:
user_request: 用户请求文本
Returns:
Agent 的响应
"""
# 步骤一:识别任务(简化实现)
print(f"\n 用户请求: {user_request}")
# 步骤二:判断能力边界(简化实现)
needs_skill = self.needs_skill(user_request)
if not needs_skill:
print(" 任务简单,无需 Skill")
return self.simple_response(user_request)
# 步骤三:匹配 Skill
matched_skill = self.skill_executor.match_skill(user_request)
if not matched_skill:
print(" 未找到合适的 Skill,使用默认处理")
return self.simple_response(user_request)
# 步骤四:执行 Skill(注入 Prompt)
system_prompt = self.build_system_prompt(matched_skill)
print(f"\n 系统提示词已更新,注入 Skill: {matched_skill['name']}")
print(f" 系统提示词长度: {len(system_prompt)} 字符")
# 步骤五:整合输出(这里简化为返回系统提示词)
return f"已激活 Skill: {matched_skill['name']}\n系统提示词已更新"
def needs_skill(self, user_request: str) -> bool:
"""
判断任务是否需要 Skill
Args:
user_request: 用户请求文本
Returns:
是否需要 Skill
"""
# 改进的判断逻辑:包含中英文关键词则需要 Skill
skill_keywords = [
# 中文关键词
'测试', '重构', '部署', '分析', '生成', '设计', '学习路径', '课程',
# 英文关键词
'test', 'refactor', 'deploy', 'analyze', 'generate', 'design',
'learning path', 'course', 'plan', 'create', 'build'
]
user_request_lower = user_request.lower()
return any(keyword.lower() in user_request_lower for keyword in skill_keywords)
def simple_response(self, user_request: str) -> str:
"""
简单响应(不使用 Skill)
Args:
user_request: 用户请求文本
Returns:
简单响应
"""
return f"收到请求: {user_request}\n使用默认处理流程"
# 初始化 Agent
agent = AgentWithSkills(skills_dir="./skills")
# 示例一:需要 Skill 的请求
print("=" * 60)
print("示例一:设计学习路径(英文请求)")
print("=" * 60)
response = agent.process_request("design a learning path for Python")
print(f"\n Agent 响应:\n{response}")
# 示例二:不需要 Skill 的请求
print("\n" + "=" * 60)
print("示例二:简单问答")
print("=" * 60)
response = agent.process_request("什么是 Python?")
print(f"\n Agent 响应:\n{response}")
# 示例三:查看注入后的完整系统提示词
print("\n" + "=" * 60)
print("示例三:查看注入后的完整系统提示词")
print("=" * 60)
matched_skill = agent.skill_executor.match_skill("design a learning path for Python")
if matched_skill:
system_prompt = agent.build_system_prompt(matched_skill)
print(f"\n 完整的系统提示词 ({len(system_prompt)} 字符):")
print("=" * 60)
print(system_prompt)
print("=" * 60)
else:
print(" 未找到匹配的 Skill")
# 示例四:对比注入前后的差异
print("\n" + "=" * 60)
print("示例四:对比注入前后的系统提示词")
print("=" * 60)
print("\n【注入前】基础系统提示词:")
print("-" * 60)
base_prompt = agent.build_system_prompt(skill=None)
print(base_prompt)
print("-" * 60)
matched_skill = agent.skill_executor.match_skill("design a learning path for Python")
if matched_skill:
print(f"\n【注入后】激活 Skill: {matched_skill['name']}")
print("-" * 60)
enhanced_prompt = agent.build_system_prompt(matched_skill)
print(enhanced_prompt)
print("-" * 60)
print(f"\n 提示词增长: {len(base_prompt)} → {len(enhanced_prompt)} 字符 (+{len(enhanced_prompt) - len(base_prompt)} 字符)")
这段代码展示了 Prompt 注入的核心机制。build_system_prompt() 方法将 Skill 的 description 和 body 注入到系统提示词中,形成一个完整的执行指南。process_request() 方法实现了完整的五步流程:识别任务 → 判断能力边界 → 匹配 Skill → 执行 Skill(注入 Prompt)→ 整合输出。
这个注入机制的关键在于:Skill 的内容不是"代码",而是"提示词"。Agent 通过读取 Skill 的 body,将其作为执行指南注入到系统提示词中,从而"学会"如何完成这个任务。
10.5.3 完整的执行流程演示
10.5.3.1 选择一个简单的 Skill 案例
为了更好地理解 Skill 的执行流程,我们选择一个结构简单、逻辑清晰的 Skill 作为案例:verification-before-completion。
这个 Skill 的核心功能是:在声称任务完成之前,强制要求先运行验证命令并确认输出。它的设计理念非常简单——"先验证,再声明"(Evidence before claims)。
让我们先看看这个 Skill 的基本信息:
.center { width: auto; display: table; margin-left: auto; margin-right: auto; }verification-before-completion Skill 基本信息
| 属性 | 值 |
|---|---|
| Skill 名称 | verification-before-completion |
| 代码行数 | 134 行 |
| 外部文件 | 无(所有内容都在 SKILL.md 中) |
| Workflow 步骤 | 5 步 |
| 核心原则 | Evidence before claims(先验证再声明) |
| 适用场景 | 提交代码前、声称任务完成前 |
这个 Skill 的结构要简单得多:所有逻辑都在一个文件中,没有外部依赖。这使得它非常适合用来理解 Skill 的执行机制。
10.5.3.2 Skill 的核心内容结构
让我们看看 verification-before-completion 的 SKILL.md 文件包含哪些核心部分:
---
name: verification-before-completion
description: Use when about to claim work is complete, fixed, or passing,
before committing or creating PRs - requires running verification
commands and confirming output before making any success claims
---
# Verification Before Completion
## Overview
核心原则:Evidence before claims, always.
## The Iron Law
NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE
## The Gate Function (5 步验证流程)
1. IDENTIFY: What command proves this claim?
2. RUN: Execute the FULL command (fresh, complete)
3. READ: Full output, check exit code, count failures
4. VERIFY: Does output confirm the claim?
5. ONLY THEN: Make the claim
## Common Failures (常见错误表格)
列举了各种常见的错误场景和正确做法
## Red Flags - STOP (危险信号)
列举了需要立即停止的危险信号
从结构上看,这个 Skill 包含以下几个关键部分:
-
Frontmatter(YAML 头部):定义 Skill 的名称和描述
-
Overview(概述):说明核心原则
-
The Iron Law(铁律):强调核心规则
-
The Gate Function(门控函数):定义 5 步验证流程
-
Common Failures(常见错误):列举错误场景
-
Red Flags(危险信号):列举需要警惕的信号
这种结构非常清晰:先说明原则,再给出具体步骤,最后列举常见错误。这正是一个好的 Skill 应该具备的结构。
2.5.3.3 Skill 执行流程解析
现在让我们深入分析:当用户发出请求 "帮我提交这段代码" 时,系统是如何执行 verification-before-completion 这个 Skill 的?
第一阶段:Skill 激活与匹配
当用户说 "帮我提交这段代码" 时,系统会经历以下步骤:
- AgentWithSkills.process_request() 接收用户请求
- needs_skill() 判断是否需要 Skill
- 检测到关键词 "提交"(对应英文 "commit")
- 返回
True
- SkillExecutor.match_skill() 匹配最合适的 Skill
- 在所有 Skills 中搜索描述包含 "commit" 的 Skill
- 找到
verification-before-completion(描述中包含 "before committing") - 返回匹配分数(例如:2 分)
- build_system_prompt() 将 Skill 内容注入到系统提示词
这个过程就像是在图书馆找书:先判断需要什么类型的书(needs_skill),然后在书架上找到最匹配的那本(match_skill),最后把书的内容展示给读者(build_system_prompt)。
第二阶段:系统提示词注入
注入后的系统提示词会变成这样:
你是一个智能助手,可以帮助用户完成各种任务。
你可以调用已加载的 Skill 来完成复杂的工作流。
# 当前激活的 Skill: verification-before-completion
## Skill 描述
Use when about to claim work is complete, fixed, or passing,
before committing or creating PRs - requires running verification
commands and confirming output before making any success claims
## Skill 执行指南
[完整的 SKILL.md 内容,包括 5 步验证流程、常见错误等]
请严格按照上述 Skill 的 Workflow 执行任务。
这就像是给 LLM 提供了一份详细的"作业指导书",不仅告诉它要做什么(验证后再提交),还告诉它应该怎么做(5 步验证流程)。
第三阶段:按照 Workflow 执行
LLM 接收到增强后的系统提示词后,会按照 "The Gate Function" 中定义的 5 步流程执行:
步骤 1: IDENTIFY(识别验证命令)
└─> 问题:"提交代码前需要验证什么?"
└─> 答案:"需要运行测试命令,确保所有测试通过"
步骤 2: RUN(运行完整命令)
└─> 执行:pytest tests/ 或 npm test
└─> 注意:必须是完整命令,不能只运行部分测试
步骤 3: READ(读取完整输出)
└─> 检查:退出码(exit code)
└─> 统计:失败数量(failures count)
└─> 读取:完整的输出信息
步骤 4: VERIFY(验证输出是否确认声明)
└─> 判断:输出是否显示 "0 failures"?
└─> 如果 NO:报告实际状态("有 3 个测试失败")
└─> 如果 YES:继续下一步
步骤 5: ONLY THEN(只有在验证通过后才能声明)
└─> 声明:"所有测试通过,可以提交代码"
└─> 附带证据:"[pytest 输出: 34/34 passed]"
这个流程的关键在于:每一步都是强制性的,不能跳过。如果 LLM 试图在没有运行验证命令的情况下说 "测试应该通过",就违反了 Skill 的规则。
10.5.3.4 为什么不需要读取外部文件?
你可能会问:为什么 verification-before-completion 不需要像 learning-path-architect 那样读取外部的 references 文件?
答案很简单:因为它的逻辑足够简单,所有信息都可以放在一个文件中。
让我们对比一下两种 Skill 的复杂度:
.center { width: auto; display: table; margin-left: auto; margin-right: auto; }两种 Skill 的复杂度对比
| 对比维度 | verification-before-completion | learning-path-architect |
|---|---|---|
| 核心逻辑 | 5 步验证流程 | 10 步学习路径设计流程 |
| 外部文件 | 0 个 | 10+ 个 references 文件 |
| 决策分支 | 简单(验证通过/失败) | 复杂(quick-start/mastery/project-driven) |
| 知识领域 | 单一(代码验证) | 多领域(教育学、知识图谱、项目管理) |
| 适合场景 | 所有代码提交场景 | 需要定制化的学习路径设计 |
从表格中可以看出:
- 简单 Skill(如 verification-before-completion):逻辑单一,所有内容都在 SKILL.md 中
- 复杂 Skill(如 learning-path-architect):涉及多个知识领域,需要拆分为多个 references 文件
这种设计遵循了"渐进式披露"(Progressive Disclosure)的原则:简单的 Skill 保持简单,复杂的 Skill 才引入外部文件。
2.5.3.5 完整执行流程图
让我们用一个完整的流程图来总结 verification-before-completion 的执行过程:
从流程图中可以看出,整个执行过程可以分为三个大阶段:
- 激活阶段:识别任务("提交代码") → 匹配 Skill → 注入提示词
- 执行阶段:按照 5 步验证流程执行 → 运行验证命令 → 读取输出
- 决策阶段:验证输出 → 如果通过则声明成功 → 如果失败则报告实际状态
这个流程的设计非常巧妙:它不是简单的"提示词拼接",而是一个结构化的执行框架。Skill 通过明确的规则和步骤,确保 LLM 不会在没有验证的情况下声称任务完成。
10.5.3.6 核心设计原则总结
通过对 verification-before-completion 的深度解析,我们可以总结出 Skill 系统的几个核心设计原则:
-
单一职责原则:每个 Skill 只做一件事,并把它做好
verification-before-completion只负责验证,不负责其他
-
渐进式披露:简单的 Skill 保持简单,复杂的 Skill 才引入外部文件
- 简单 Skill:所有内容在 SKILL.md 中
- 复杂 Skill:拆分为 SKILL.md + references/ + scripts/
-
强制执行规则:通过明确的 Workflow 和约束,确保 LLM 按规则执行
- "The Iron Law":NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE
- "The Gate Function":5 步验证流程,缺一不可
-
可验证性:Skill 的执行结果必须是可验证的
- 不能说 "应该通过",必须说 "已验证通过,输出为 [具体输出]"
这些设计原则不仅适用于 verification-before-completion,也适用于所有其他 Skills。理解了这些原则,你就能够更好地设计和使用 Agent Skills 系统。
💡 关键洞察:Skill 系统的强大之处在于它将"规则"和"执行"分离。SKILL.md 定义了规则(做什么、怎么做、不能做什么),LLM 负责执行。这种分离使得系统既灵活又可控——你可以修改规则而不改变 LLM,也可以升级 LLM 而不改变规则。
更重要的是,Skill 系统通过结构化的 Workflow 和明确的约束,将 LLM 从"自由发挥"变成了"按规则执行"。这正是 Agent Skills 能够可靠完成复杂任务的关键所在。