一、从"万能工具人"到"专业团队"
1.1 Agent 的困境
想象你要构建一个 AI 助手来帮你处理日常工作：
# 一个"万能" Agent 的尝试agent = Agent( prompt=""" 你是一个全能助手，需要处理： - 代码审查（支持 Python/Java/Go/Rust...） - 数据分析（SQL/Pandas/可视化） - 文档生成（Markdown/LaTeX/Word） - 邮件处理（SMTP/IMAP） - 日程管理（Google Calendar） - 项目管理（JIRA/GitHub Issues） - 财务分析（Excel/会计规则） ...（还有十几页的详细说明） """)
问题来了：
❌ Prompt 会变得超长 → 超出上下文限制，每次调用消耗上万 tokens ❌ 什么都会 = 什么都不精 → 每个任务都做得马马虎虎 ❌ 代码难以维护 → 修改一个功能影响整体 ❌ 无法复用 → 每个项目都要重新配置 ❌ 协作困难 → 团队无法分工开发不同能力
1.2 现实世界的启示
现实中我们是怎么解决复杂问题的？
❌ 不好的方式： 雇一个人做所有事情✅ 好的方式： ┌─────────────────────────────────────┐ │ 项目经理（协调者） │ └──────────┬──────────────────────────┘ │ ┌────────┼────────┬────────┬────────┐ ▼ ▼ ▼ ▼ ▼ 开发工程师 测试工程师 设计师 数据分析师 运维工程师 (专精代码) (专精测试) (专精UI) (专精分析) (专精部署)
每个人都有自己的专业技能（Skill），通过协作完成复杂任务。
1.3 人类是如何学习的？
当你入职一家新公司，是这样学习的吗？
❌ 不现实的方式：
第一天上班：老板把一本 5000 页的公司手册塞给你"把这些全背下来，然后开始工作！"
✅ 实际的方式：
第一天：老板：我们有开发、测试、运维三个部门，你在开发部第一周：需要写代码时 → 查阅《开发规范》需要提交时 → 查阅《Git 工作流》第一个月：遇到部署问题 → 请教运维同事需要写测试 → 翻阅《测试指南》逐渐掌握：只学习当前工作需要的知识其他知识放在知识库里，需要时再查
这就是 渐进式学习（Progressive Learning）：
不是一次性学习所有知识，而是在需要时按需加载相关知识
二、什么是 Agent Skills？
2.1 核心理念
Agent Skills 的设计理念正是基于这个思想：
不要构建一个万能的巨型 Agent，而是让 Agent 拥有一组可组合的专业技能，需要时按需加载
Agent Skill = 一个独立的、可复用的、专注于特定领域的能力模块
它就像给 Agent 安装了一个"插件"或"应用程序"：
Agent（基础能力） + Skill: 代码审查专家 + Skill: Python 单元测试生成器 + Skill: Git 提交分析器 + Skill: API 文档生成器 ────────────────────────── = 一个专业的代码助手
2.2 官方定义
根据 Anthropic 官方文档：
Agent Skills are modular capabilities that extend Claude’s functionality. Each Skill packages instructions, metadata, and optional resources (scripts, templates) that Claude uses automatically when relevant.
关键特性：
- 📦 模块化能力扩展
- 📝 包含指令、元数据、可选资源（脚本、模板）
- 🎯 相关时自动使用
- 🔄 跨对话复用
2.3 Skill vs Tool vs Prompt：三者的本质区别
很多人会混淆这三个概念，让我们深入厘清它们：
基础对比表
| 维度 | Tool（工具） | Skill（技能） | Prompt（提示） |
|---|---|---|---|
| 粒度 | 单一操作 | 完整能力 | 单次指令 |
| 复杂度 | 简单函数调用 | 多工具+知识+流程 | 文本指令 |
| 作用域 | 无状态 | 领域专家级 | 当前对话 |
| 复用 | 可复用 | 跨项目复用 | 不可复用 |
| 加载 | 总是可用 | 按需加载 | 每次传递 |
| Token | 工具定义占用少 | 渐进式加载 | 每次都消耗 |
举例说明
# ❌ Tool（只是一个工具）def read_file(path: str) -> str: """读取文件内容""" return open(path).read()# ❌ Prompt（只是一次性指令）prompt = "你是代码审查专家，请检查这个文件的代码质量"# ✅ Skill（完整的能力包）# 包含：指令文档、工作流程、脚本、参考资料code-review-skill/├── SKILL.md # 指令：如何审查代码├── CHECKLIST.md # 检查清单├── scripts/│ ├── detect_bugs.py # 脚本：自动检测问题│ └── analyze_complexity.py└── references/ ├── owasp_top10.md # 参考：安全漏洞清单 └── pep8_guide.md # 参考：Python 规范
关键区别：
- Tool = “锤子”（单一工具）
- Prompt = “今天的工作指令”
- Skill = “木工师傅的手艺”（知道何时用锤子、何时用锯子、如何组合使用，还有多年经验总结的诀窍）
深度对比：Skills vs 直接给所有 Tools
这是一个常见的误解：给 Agent 一堆 Tools ≠ 给 Agent Skills
让我们通过一个完整案例来理解本质区别：
场景：PDF 表单填写任务
用户请求：“填写这个 PDF 表单，name 字段填 ‘John’, email 填 ‘john@example.com’”
方案 A：直接给 Agent 150 个工具
from anthropic import Anthropicclient = Anthropic()# 定义所有工具tools = [ { "name": "read_file", "description": "Read a file", "input_schema": {"type": "object", "properties": {"path": {"type": "string"}}} }, { "name": "extract_pdf_text", "description": "Extract text from PDF", "input_schema": {"type": "object", "properties": {"path": {"type": "string"}}} }, { "name": "fill_pdf_form", "description": "Fill PDF form fields", "input_schema": { "type": "object", "properties": { "pdf_path": {"type": "string"}, "field_data": {"type": "object"} } } }, # ... 还有 147 个其他工具]response = client.messages.create( model="claude-3-5-sonnet-20241022", max_tokens=4096, tools=tools, # 传递 150 个工具定义 messages=[{ "role": "user", "content": "填写这个 PDF 表单..." }])
Agent 的困境：
Claude 的内心 OS："我有这 150 个工具...- read_file: 好像能读文件- extract_pdf_text: 提取文本？但我需要填表单- fill_pdf_form: 这个好像是对的！但是：- 我应该先验证表单字段吗？（没有文档告诉我）- 字段名映射规则是什么？（我不知道）- 填写失败了怎么处理？（没有最佳实践）- 有没有更好的方法？（我只能靠猜测）让我尝试调用 fill_pdf_form...（可能会失败，因为没有验证字段）失败了！让我再试试其他方法...（需要多次试错）"
Token 消耗：
- 工具定义：~15,000 tokens（每次请求）
- Agent 思考：~3,000 tokens
- 试错过程：~5,000 tokens
- 总计：~23,000 tokens
方案 B：使用 PDF Processing Skill
from anthropic import Anthropicclient = Anthropic()# 只传递 1 个 Skill 容器response = client.messages.create( model="claude-3-5-sonnet-20241022", max_tokens=4096, tools=[{ "type": "code_execution", "container_id": "pdf"# PDF Skill }], messages=[{ "role": "user", "content": "填写这个 PDF 表单..." }])# PDF Skill 内部包含：# - Level 1 (元数据): "PDF 处理 - 提取文本、表格、填表单、合并..."# - Level 2 (主指令): SKILL.md 包含完整的表单填写流程# - Level 3 (资源): 预制的验证和填充脚本
Agent 的执行过程：
Claude 触发 PDF SkillLevel 1 (启动时已加载):"PDF 处理 - 提取文本、表格、填表单、合并文档"Level 2 (读取 SKILL.md):bash: cat /skills/pdf-skill/SKILL.md从 SKILL.md 学到：━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━# PDF 表单填写## 标准流程1. **验证表单字段** bash: python scripts/validate_form.py input.pdf 这会： - 检查 PDF 是否包含表单 - 列出所有可填写字段 - 验证字段类型2. **准备数据** 数据格式：JSON {"field_name": "value"}3. **填写表单** bash: python scripts/fill_form.py input.pdf data.json output.pdf4. **验证结果** bash: python scripts/check_form.py output.pdf## 常见问题- 字段名不匹配 → 查看 schemas/field_mappings.json- PDF 加密 → 先使用 decrypt 功能- 填写失败 → 检查字段类型是否匹配━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━Claude："太好了！我知道完整的流程了！"执行步骤：1. bash: python scripts/validate_form.py invoice.pdf 输出： { "valid": true, "fields": ["name", "email"], "field_types": {"name": "text", "email": "text"} }2. 准备数据： {"name": "John", "email": "john@example.com"}3. bash: python scripts/fill_form.py invoice.pdf data.json filled.pdf 输出： { "success": true, "filled_fields": 2, "message": "表单填写成功" }4. bash: python scripts/check_form.py filled.pdf 输出： { "valid": true, "all_required_filled": true }完成！✓
Token 消耗：
- Skill 容器：~100 tokens
- SKILL.md：~3,000 tokens
- 脚本输出（4次）：~300 tokens
- Agent 思考：~1,000 tokens
- 总计：~4,400 tokens
效率提升：5.2 倍！✨
本质区别总结
| 维度 | 直接给工具 | Skills |
|---|---|---|
| 本质 | 函数调用接口 | 专家知识包 |
| 包含内容 | ❌ 只有工具定义 | ✅ 工具 + 知识 + 流程 + 经验 + 脚本 |
| 领域知识 | ❌ 没有！ Agent 需要自己摸索 | ✅ 专家级知识 • 何时用哪个工具 • 如何组合工具 • 最佳实践 • 常见陷阱 |
| 工作流程 | ❌ 缺失 Agent 需要试错 | ✅ 封装了标准流程 “先验证 → 填充 → 检查” |
| 脚本支持 | ❌ 没有 复杂逻辑让 Agent 生成代码 | ✅ 预制脚本 • 200 行代码不进入上下文！ • 只有输出消耗 tokens |
| Token 效率 | ❌ 固定且高 每次 15,000+ tokens | ✅ 渐进式 按需加载，节省 50-80% |
| 任务成功率 | ⚠️ 60-70% 需要摸索和试错 | ✅ 90-95% 有专家知识指导 |
类比说明
给 Agent 工具 vs 给 Agent Skills，就像：❌ 方案 A（给工具）：┌──────────────────────────┐│ 给新员工一个工具箱： ││ • 螺丝刀 ││ • 锤子 ││ • 扳手 ││ • 电钻 ││ • ...（150个工具） ││ ││ 说：自己想办法完成任务！ │└──────────────────────────┘↓问题：❌ 不知道什么场景用什么工具❌ 不知道正确使用方法❌ 需要大量试错❌ 效率低下，质量参差✅ 方案 B（给 Skills）：┌──────────────────────────┐│ 给新员工： ││ 1. 工具箱（工具） ││ 2. 《作业指导书》（知识） ││ • 标准操作流程 ││ • 质量检查清单 ││ • 常见问题解决方案 ││ • 最佳实践 ││ 3. 师傅带教（工作流） ││ 4. 自动化脚本（效率工具） │└──────────────────────────┘↓结果：✅ 知道何时用什么工具✅ 知道正确的操作方法✅ 避免常见错误✅ 高效且高质量地完成任务
这不是量的差别，而是质的差别！
三、为什么需要 Agent Skills？
3.1 解决的核心问题
✅ 问题 1：能力复用
没有 Skills 之前：
# 项目 A：电商客服 Agentagent_a = Agent( prompt="你是客服，需要处理订单查询、退款、投诉...")# 项目 B：电商数据分析 Agentagent_b = Agent( prompt="你是数据分析师，需要处理订单查询、销售分析...")# 问题：订单查询能力在两个项目中重复实现 ❌
有了 Skills 之后：
# 定义可复用的 Skillorder_skill = Skill(name="订单查询")# 项目 Aagent_a = Agent(skills=[order_skill, refund_skill, complaint_skill])# 项目 Bagent_b = Agent(skills=[order_skill, analytics_skill])# ✅ 订单查询能力被复用，维护成本降低
✅ 问题 2：专业性和质量
没有 Skills：Agent 什么都会一点，但都不精通
# 一个"万能" Agentagent = Agent( prompt="你需要处理代码审查、数据分析、邮件处理...")# 结果：# - 代码审查：只能发现明显的语法错误# - 数据分析：只会基础的统计# - 邮件处理：只能做简单的分类
有了 Skills：每个 Skill 专注于一个领域，质量更高
# 专业的代码审查 Skillcode_review_skill = Skill( name="高级代码审查专家", knowledge=""" - OWASP Top 10 安全漏洞 - 12-Factor App 最佳实践 - 语言特定的性能优化模式 - 常见设计模式的误用 - 可测试性评估标准 """, tools=[ ast_parser, security_scanner, complexity_analyzer, test_coverage_checker ])# 结果：能发现深层次的问题# ✅ 检测到 SQL 注入风险# ✅ 发现循环复杂度过高# ✅ 识别出未处理的异常路径
✅ 问题 3：可组合性
Skills 可以像"乐高积木"一样自由组合：
# 场景 1：代码助手code_assistant = Agent(skills=[ code_review_skill, unit_test_generator_skill, documentation_skill])# 场景 2：全栈开发助手fullstack_assistant = Agent(skills=[ code_review_skill, # 复用！ frontend_skill, backend_skill, database_design_skill, deployment_skill])# 场景 3：安全审计专家security_auditor = Agent(skills=[ code_review_skill, # 复用！ penetration_testing_skill, compliance_check_skill])
✅ 问题 4：Token 效率 - 渐进式加载 ⭐
这是 Skills 最核心的创新！
传统 Prompt 方式：
# 每次对话都要传递完整的知识prompt = """你是 PDF 处理专家，你需要：1. PDF 文本提取（使用 pdfplumber...） - 基础提取：...（500 字说明） - 表格提取：...（500 字说明） - OCR 处理：...（500 字说明）2. PDF 表单填写（使用 PyPDF2...） - AcroForm 填写：...（800 字说明） - XFA 表单：...（800 字说明） - 字段映射：...（500 字说明）3. PDF 合并拆分（使用 PyPDF2...） ...（还有几千字）（总计：~10,000 tokens）"""# 问题：# - 用户只想提取文本，却加载了表单、合并等所有知识# - 每次对话都消耗 10,000 tokens
Skills 的渐进式加载：
# Claude API 调用response = client.messages.create( model="claude-3-5-sonnet-20241022", tools=[{"type": "code_execution", "container_id": "pdf"}], messages=[{"role": "user", "content": "提取这个 PDF 的文本"}])# 实际消耗：# Level 1 (元数据): ~100 tokens - 总是加载# Level 2 (基础指令): ~2000 tokens - 触发 PDF Skill 时加载# Level 3 (表单填写文档): 0 tokens - 不需要，不加载！# ────────────────────────────# 总计：~2100 tokens（节省 79%！）
✅ 问题 5：团队协作
Skills 让团队可以分工开发 Agent 能力：
团队分工：┌─────────────────────────────────────────┐│ 张三：负责开发 SQL 分析 Skill ││ 李四：负责开发 数据可视化 Skill ││ 王五：负责开发 报告生成 Skill │└─────────────────────────────────────────┘ │ ▼ Skills 集成到主 Agent │ ▼ 完整的数据分析 AI 助手
3.2 实际场景对比
场景：构建一个 GitHub 代码助手
❌ 没有 Skills 的方案：
agent = Agent( prompt=""" 你是 GitHub 助手，需要： 1. 审查 Pull Request（检查代码质量、安全问题、测试覆盖率） 2. 自动生成 Changelog 3. 管理 Issue（分类、优先级、分配） 4. 生成项目文档 5. 监控 CI/CD 流水线 6. 分析代码统计数据 ...（上百行 prompt） """)# 问题：# - Prompt 太长，容易超限# - 难以维护（改一个功能要重新测试整体）# - 无法复用（其他项目要重新写）# - 质量参差不齐（每个功能都不够深入）
✅ 有 Skills 的方案：
# 每个 Skill 独立开发和测试github_assistant = Agent(skills=[ pr_review_skill, # PR 审查专家 changelog_skill, # 变更日志生成器 issue_manager_skill, # Issue 管理专家 documentation_skill, # 文档生成器 ci_monitor_skill, # CI/CD 监控 stats_analyzer_skill # 代码统计分析])# 优势：# ✅ 每个 Skill 可以独立维护和升级# ✅ 可以在多个项目中复用（GitLab、Bitbucket）# ✅ 新人可以只学习相关的 Skill# ✅ 可以轻松添加新功能（新增 Skill 即可）
3.3 从第一性原理思考 Skills ⭐
什么是第一性原理？
“First principles thinking is about breaking down complex problems into their fundamental truths and reasoning up from there.”
第一性原理思维就是把复杂问题分解到基本事实，然后从那里重新推导。
马斯克的经典例子：
问题：电动车电池太贵了（2008年）❌ 传统思维（类比思维）： - 别人的电池包卖 $600/kWh - 所以我们的也要这个价格 - 这就是市场价格✅ 第一性原理思维： - 电池由什么构成？→ 钴、镍、铝、碳、聚合物 - 这些材料在伦敦金属交易所的价格？→ $80/kWh - 那为什么成品卖 $600？→ 因为传统制造流程 - 能否重新设计制造流程？→ Yes! - 结果：Tesla 把成本降到了 $100/kWh
Skills 设计的第一性原理推导
问题：如何让 AI Agent 具备专业能力？
传统思维（类比现有方案）❌
# 思路：给 Agent 更多工具agent = Agent( tools=[tool1, tool2, tool3, ..., tool150] # 堆砌工具)# 思路：给 Agent 更长的 Promptagent = Agent( prompt=""" 你是专家，你需要知道： - PDF 处理的 50 种方法 - 数据分析的 100 个技巧 - 代码审查的 200 个要点 ... (10万字的知识) """)
问题：
- 这只是"堆砌"现有方案
- 受限于上下文窗口
- Token 成本线性增长
- 没有突破性创新
第一性原理思维（回到本质）✅
Step 1: 什么是"具备专业能力"的本质？
不是：❌ 拥有所有工具❌ 记住所有知识而是：✅ 知道在需要时去哪里找知识✅ 知道如何组合使用知识和工具✅ 有领域专家的思维方式
Step 2: 人类专家是如何工作的？
观察：一个资深的 PDF 处理工程师他的大脑里存储了什么？❌ 不是：所有 PDF 库的完整 API 文档（那是几千页）✅ 而是： - 核心概念和原理（PDF 的结构） - 常见场景的处理模式 - 遇到问题时去哪里查资料 - 哪些库适合什么场景他如何解决新问题？1. 理解问题 → 匹配到已知模式2. 如果是常见场景 → 直接应用经验3. 如果是新场景 → 查阅参考资料、运行工具脚本4. 只加载当前需要的知识
这就是人类的"按需加载"机制！
Step 3: 从基本事实推导
让我们列出不可辩驳的基本事实：
基本事实：1. ✅ 上下文窗口有限（物理限制）2. ✅ 不同任务需要不同知识（事实）3. ✅ 大部分知识在单次任务中用不到（观察）4. ✅ 人类通过"按需加载"高效工作（生物学事实）5. ✅ 文件系统可以存储无限知识（技术事实）6. ✅ 代码执行不占用思考空间（计算机科学事实）
从这些基本事实推导：
如果：上下文有限 + 知识无限那么：不能一次性加载所有知识 ↓ 必须按需加载如果：任务不同需要不同知识 + 大部分知识用不到那么：应该根据任务动态选择加载内容 ↓ 需要元数据来描述"何时使用这个知识"如果：人类通过"按需查阅手册"高效工作那么：Agent 也应该有可查阅的"手册" ↓ 知识应该组织成可检索的文档如果：文件系统可以存储无限知识 + Agent 能读文件那么：把知识存在文件系统，用 bash 按需读取 ↓ 实现渐进式加载如果：代码执行不占上下文 + Agent 能执行脚本那么：把复杂逻辑封装成脚本，只让输出进入上下文 ↓ 实现高效的确定性操作━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━推导结果：Skills 的三级渐进式加载架构Level 1: 元数据（总是加载）- 告诉 Agent 有哪些 SkillsLevel 2: 指令文档（触发时加载）- 教 Agent 如何使用Level 3: 资源和脚本（按需加载）- 提供详细资料和工具
这就是第一性原理！
不是简单地"给 Agent 更多工具"或"更长的 Prompt"， 而是回到"人类如何高效工作"这个基本事实， 重新设计 Agent 的知识组织和加载机制。
Skills 为什么更符合第一性原理？
| 原理 | 传统方案 | Skills 方案 |
|---|---|---|
| 信息处理能力有限 （人脑/AI 都有上下文限制） | ❌ 试图突破限制 （塞进更多信息） | ✅ 顺应限制 （按需加载） |
| 专业化比全能更高效 （生物进化的结果） | ❌ 试图让 Agent “全能” （什么都会一点） | ✅ 专业化分工 （每个 Skill 专精领域） |
| 记忆访问的局部性原理 （计算机科学基本原理） | ❌ 违背局部性 （每次都加载所有） | ✅ 遵循局部性 （只加载需要的） |
| 分而治之 （工程学基本原理） | ❌ 整体式设计 （一个大 Prompt） | ✅ 模块化设计 （多个独立 Skills） |
实际效果验证
真实场景：支持 5 个领域（PDF、Excel、Word、代码审查、数据分析）的 Agent
| 方案 | 启动成本 | 单次任务成本 | 10 次任务总成本 | 成本（$3/1M tokens） |
|---|---|---|---|---|
| 传统方案 （200 个工具定义 + 长 Prompt） | 20,000 tokens | 20,000 tokens | 200,000 tokens | $0.60 |
| Skills 方案 （5 个 Skills） | 500 tokens | 平均 5,000 tokens | 50,500 tokens | $0.15 |
| 效率提升 | 40 倍 | 4 倍 | 约 4 倍 | 节省 75% |
这就是第一性原理思维的威力：不是渐进式改进，而是量级的突破！ 🚀
四、Skills 的渐进式加载架构 ⭐
这是 Skills 最核心的创新：三级渐进式加载（Progressive Disclosure）
4.1 架构图解
┌──────────────────────────────────────────────────────────┐│ 启动时（System Prompt） ││ ││ Level 1: 所有 Skills 的元数据（轻量级） ││ ┌───────────────────────────────────────────┐ ││ │ • PDF 处理 - 提取文本、填表单、合并文档 │ ││ │ • Excel 分析 - 数据分析、生成图表 │ ││ │ • 代码审查 - 检查安全漏洞、性能问题 │ ││ │ • ... (可能有 50 个 Skills) │ ││ └───────────────────────────────────────────┘ ││ ││ Token 成本：~100 tokens/Skill ││ 50 个 Skills = ~5000 tokens │└──────────────────────────────────────────────────────────┘ │ │ 用户："提取这个 PDF 的文本" │ Claude 识别需要 PDF 处理 Skill ▼┌──────────────────────────────────────────────────────────┐│ 触发 Skill（读取主指令） ││ ││ Level 2: bash: cat /skills/pdf-skill/SKILL.md ││ ┌───────────────────────────────────────────┐ ││ │ # PDF 处理 │ ││ │ │ ││ │ ## 文本提取 │ ││ │ 使用 pdfplumber： │ ││ │ ```python │ ││ │ import pdfplumber │ ││ │ with pdfplumber.open("file.pdf") as pdf: │ ││ │ text = pdf.pages[0].extract_text() │ ││ │ ```│ ││ │ │ ││ │ 需要表单填写？→ [FORMS.md](FORMS.md) │ ││ │ 需要合并文档？→ [MERGE.md](MERGE.md) │ ││ └───────────────────────────────────────────┘ ││ ││ Token 成本：< 5000 tokens │└──────────────────────────────────────────────────────────┘ │ │ Claude 判断：只需要文本提取 │ 不需要表单填写和合并功能 ▼┌──────────────────────────────────────────────────────────┐│ 执行任务（按需读取额外资源） ││ ││ Level 3: 如果需要，读取/执行额外资源 ││ ┌───────────────────────────────────────────┐ ││ │ 如果用户要填表单: │ ││ │ → bash: cat FORMS.md (文档进入上下文) │ ││ │ │ ││ │ 如果需要验证: │ ││ │ → bash: python scripts/validate.py │ ││ │ → 只有输出进入上下文，代码本身不消耗！ │ ││ │ │ ││ │ 本次任务：都不需要 → 0 tokens │ ││ └───────────────────────────────────────────┘ ││ ││ Token 成本：本次为 0 │└──────────────────────────────────────────────────────────┘
4.2 三级加载详解
Level 1: 元数据（Metadata）- 总是加载
内容：SKILL.md 的 YAML frontmatter
---name:pdf-processingdescription:ExtracttextandtablesfromPDFfiles,fillforms,mergedocuments.UsewhenworkingwithPDFfilesorwhentheusermentionsPDFs,forms,ordocumentextraction.---
何时加载：Agent 启动时（包含在 system prompt）
Token 成本：~100 tokens/Skill
作用：
- Claude 知道有哪些 Skills 可用
- 知道何时应该使用每个 Skill
- 轻量级 → 可以安装数十个 Skills 而不影响性能
类比：书架上贴的标签，告诉你每本书是关于什么的
Level 2: 指令（Instructions）- 触发时加载
内容：SKILL.md 的主体内容
# PDF 处理## 快速开始使用 pdfplumber 提取文本：```pythonimport pdfplumberwith pdfplumber.open("document.pdf") as pdf: text = pdf.pages[0].extract_text()```需要填写表单？查看 [FORMS.md](FORMS.md)
何时加载：用户请求匹配 Skill 的 description 时，Claude 通过 bash 命令读取
bash: cat /skills/pdf-skill/SKILL.md
Token 成本：< 5000 tokens
作用：
- 提供工作流程指导
- 包含最佳实践
- 引用其他资源
类比：打开书翻到目录和主要章节
Level 3: 资源和代码（Resources & Code）- 按需加载
内容类型：
-
额外的指令文档（Markdown）
FORMS.md # 表单填写详细指南REFERENCE.md # API 参考文档EXAMPLES.md # 更多示例 -
可执行脚本（Python/Shell）
scripts/fill_form.py # 表单填写工具scripts/validate.py # 数据验证scripts/optimize.py # PDF 优化 -
参考资料（任何文件）
templates/invoice.pdf # 模板文件schemas/database.sql # 数据库 schemadocs/api_spec.json # API 规范
何时加载：指令中引用时
加载方式：
- 文档：
bash: cat FORMS.md→ 内容进入上下文 → 消耗 tokens - 脚本：
bash: python scripts/validate.py→ 只有输出进入上下文 → 代码不消耗 tokens！ - 资源：按实际使用决定
Skill 目录结构示例：
pdf-skill/├── SKILL.md # 主指令（Level 2）├── FORMS.md # 表单填写指南（Level 3）├── REFERENCE.md # 详细 API 参考（Level 3）├── schemas/│ └── form_fields.json # 表单字段定义（Level 3）├── scripts/│ ├── fill_form.py # 填充工具（Level 3 - 只运行，不进入上下文）│ └── validate.py # 验证工具（Level 3）└── templates/ └── invoice.pdf # 发票模板（Level 3）
关键创新：
✅ 无限扩展 → 可以包含任意多的参考资料 ✅ 零成本存储 → 未使用的文件不消耗 tokens ✅ 高效脚本 → 代码执行不占用上下文
类比：
- 文档 = 翻到具体章节阅读（消耗时间）
- 脚本 = 使用书中的练习题答案（只看结果）
- 资源 = 书后的附录（需要时才查）
4.3 加载机制对比表
| 级别 | 加载时机 | Token 成本 | 内容 | 类比 |
|---|---|---|---|---|
| Level 1 | 启动时（总是） | ~100 tokens/Skill | name + description | 书架标签 |
| Level 2 | Skill 触发时 | < 5000 tokens | SKILL.md 主体 | 书的目录和主章节 |
| Level 3 | 按需引用时 | 可变（0 到无限） | 额外文档、脚本、数据 | 具体章节、附录 |
4.4 实际案例：PDF 处理流程
让我们看一个完整的例子：
from anthropic import Anthropicclient = Anthropic()response = client.messages.create( model="claude-3-5-sonnet-20241022", max_tokens=4096, tools=[{"type": "code_execution", "container_id": "pdf"}], messages=[{"role": "user", "content": "提取 invoice.pdf 的文本并总结"}])
执行流程：
1. 启动时 (Level 1)： System Prompt 包含所有 Skills 元数据： - PDF 处理: 提取文本、表格、填表单、合并文档 - Excel 分析: 数据处理、图表生成 - 代码审查: 安全检查、性能分析 ... (还有其他几十个 Skills) Token 成本：~5000 tokens（假设 50 个 Skills）2. 用户请求触发 (Level 2)： Claude 分析："需要处理 PDF" → 匹配到 "pdf-processing" 执行：bash: cat /skills/pdf-skill/SKILL.md SKILL.md 内容进入上下文： - 基础文本提取方法 - 高级功能链接（表单填写、合并等） - 常见问题处理 Token 成本：~3000 tokens3. 执行任务 (Level 3)： Claude 从 SKILL.md 学到： ✓ 文本提取用 pdfplumber（已有指令） ✗ 不需要填表单（不读取 FORMS.md） ✗ 不需要合并（不读取 MERGE.md） 执行提取，返回结果 Level 3 Token 成本：0（不需要额外资源）总 Token 成本：~8000 tokens（系统 prompt 5000 + SKILL.md 3000 + Level 3 为 0）如果使用传统 Prompt（包含所有 PDF 知识）：~20000 tokens效率提升：2.5 倍！
4.5 为什么脚本不消耗 tokens？⭐
这是很多人困惑的点。让我详细解释：
脚本执行示例：
# 脚本：validate_form.py (200 行代码)def validate_pdf_form(pdf_path, schema): # 复杂的验证逻辑 # 读取 PDF、解析字段、验证格式 # 检查必填项、数据类型、正则匹配 # ... 200 行代码 return { "valid": True, "errors": [], "warnings": ["字段 'email' 格式建议优化"] }if __name__ == "__main__": result = validate_pdf_form(sys.argv[1], sys.argv[2]) print(json.dumps(result))
Claude 执行：
# Claude 通过 bash 执行脚本bash: python scripts/validate_form.py invoice.pdf schema.json# 脚本运行，返回输出{ "valid": true, "errors": [], "warnings": ["字段 'email' 格式建议优化"]}
Token 计算：
脚本代码本身：200 行 → ~2000 tokens (如果进入上下文的话)实际进入上下文：只有输出 JSON → ~50 tokens━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━效率提升：40 倍！
对比：如果让 Claude 生成等价代码：
# 传统方式：让 Claude 生成验证代码prompt = """生成一个 Python 脚本来验证 PDF 表单：1. 读取 PDF2. 解析字段3. 验证格式4. 检查必填项5. 返回结果"""# Claude 生成的代码会进入上下文# Token 成本：~2000 tokens# 而且可能不如预制脚本准确
Skills 方式的优势：
✅ 确定性 → 脚本逻辑固定，不会出错 ✅ 高效 → 不占用 context window ✅ 复杂计算 → 可以做任意复杂的处理 ✅ 可测试 → 脚本可以单独测试 ✅ Token 友好 → 只有输出消耗 tokens
五、Claude 官方提供的 Agent Skills
在开始自己创建 Skill 之前，先了解 Anthropic 官方提供的预构建 Skills。
5.1 预构建 Agent Skills（开箱即用）
Anthropic 提供了 4 个官方 Skills，专注于办公文档处理：
| Skill ID | 名称 | 功能 |
|---|---|---|
pptx | PowerPoint | 创建演示文稿、编辑幻灯片、分析内容 |
xlsx | Excel | 创建电子表格、数据分析、生成图表 |
docx | Word | 创建文档、编辑内容、格式化文本 |
pdf | 生成格式化的 PDF 文档和报告 |
使用示例：
from anthropic import Anthropicclient = Anthropic()# 使用 PDF Skillresponse = client.messages.create( model="claude-3-5-sonnet-20241022", max_tokens=4096, tools=[{ "type": "code_execution", "container_id": "pdf"# ← 指定使用 PDF Skill }], messages=[{ "role": "user", "content": "从这个 PDF 提取文本并总结主要内容" }])# 使用 Excel Skillresponse = client.messages.create( model="claude-3-5-sonnet-20241022", max_tokens=4096, tools=[{ "type": "code_execution", "container_id": "xlsx"# ← 指定使用 Excel Skill }], messages=[{ "role": "user", "content": "分析这个销售数据并生成图表" }])
特点：
- ✅ 无需配置，直接使用
- ✅ 在 Claude API 和 claude.ai 都可用
- ✅ Anthropic 官方维护和更新
- ✅ 渐进式加载，高效使用 tokens
六、创建自定义 Skills：完整示例
6.1 Skill 目录结构
data-analysis-skill/├── SKILL.md # 必需：主指令（Level 2）├── QUICKSTART.md # 可选：快速开始（Level 3）├── ADVANCED.md # 可选：高级功能（Level 3）├── scripts/│ ├── clean_data.py # Level 3：数据清洗脚本│ ├── generate_report.py # Level 3：报告生成脚本│ └── visualize.py # Level 3：可视化脚本├── templates/│ └── report_template.html # Level 3：报告模板└── schemas/ └── data_schema.json # Level 3：数据 schema
6.2 SKILL.md（Level 2 - 主指令）
---name:data-analysis-expertdescription:Advanceddataanalysisandvisualization.Usewhentheuserneedstoanalyzedatasets,generateinsights,createvisualizations,orproducedatareports.HandlesCSV,Excel,JSONformats.---# 数据分析专家 Skill## 概述专业的数据分析能力，包括：-数据清洗和预处理-统计分析和探索性数据分析（EDA）-数据可视化-自动化报告生成## 快速开始### 基础数据分析```pythonimportpandasaspd# 加载数据df=pd.read_csv("data.csv")# 基础统计print(df.describe())# 缺失值检查print(df.isnull().sum())```### 数据清洗如果数据需要清洗，使用清洗脚本：```bashpythonscripts/clean_data.pyinput.csv--outputcleaned.csv```这会：-处理缺失值-移除重复行-规范化列名-移除异常值### 生成报告```bashpythonscripts/generate_report.pydata.csv--outputreport.html```## 进阶功能需要更复杂的分析？查看[ADVANCED.md](ADVANCED.md)：-时间序列分析-机器学习模型-A/B测试分析## 最佳实践1.**始终先探索数据**-检查数据类型、缺失值、分布2.**数据清洗**-处理缺失值和异常值3.**可视化优先**-使用图表理解数据4.**记录假设**-说明分析假设和方法选择
6.3 scripts/clean_data.py（Level 3 - 脚本）
#!/usr/bin/env python3"""数据清洗脚本用法：python clean_data.py input.csv --output cleaned.csv"""import pandas as pdimport argparseimport jsondef clean_data(df): """清洗数据框""" results = { "rows_before": len(df), "actions": [] } # 1. 移除重复行 duplicates = df.duplicated().sum() if duplicates > 0: df = df.drop_duplicates() results["actions"].append(f"移除 {duplicates} 行重复数据") # 2. 处理缺失值 missing = df.isnull().sum() for col, count in missing[missing > 0].items(): if df[col].dtype in ['float64', 'int64']: df[col].fillna(df[col].median(), inplace=True) results["actions"].append(f"{col}: 用中位数填充 {count} 个缺失值") else: df[col].fillna(df[col].mode()[0], inplace=True) results["actions"].append(f"{col}: 用众数填充 {count} 个缺失值") # 3. 移除异常值（IQR 方法） numeric_cols = df.select_dtypes(include=['float64', 'int64']).columns outliers_removed = 0 for col in numeric_cols: Q1 = df[col].quantile(0.25) Q3 = df[col].quantile(0.75) IQR = Q3 - Q1 lower = Q1 - 1.5 * IQR upper = Q3 + 1.5 * IQR before = len(df) df = df[(df[col] >= lower) & (df[col] <= upper)] outliers_removed += before - len(df) if outliers_removed > 0: results["actions"].append(f"移除 {outliers_removed} 个异常值") results["rows_after"] = len(df) return df, resultsdef main(): parser = argparse.ArgumentParser(description="数据清洗工具") parser.add_argument("input", help="输入 CSV 文件") parser.add_argument("--output", default="cleaned.csv") args = parser.parse_args() df = pd.read_csv(args.input) df_clean, results = clean_data(df) df_clean.to_csv(args.output, index=False) # 只有这个输出进入上下文！（~100 tokens） print(json.dumps(results, indent=2, ensure_ascii=False))if __name__ == "__main__": main()
6.4 使用这个 Skill
from anthropic import Anthropicclient = Anthropic()# 1. 上传 Skillskill = client.skills.create(skill_dir="/path/to/data-analysis-skill")# 2. 使用 Skillresponse = client.messages.create( model="claude-3-5-sonnet-20241022", max_tokens=8192, tools=[{"type": "code_execution", "container_id": skill.id}], messages=[{ "role": "user", "content": "分析 sales_2024.csv，清洗数据并生成报告" }])
执行过程：
1. Level 1: 元数据已加载（启动时） "数据分析专家 - 分析数据集、生成洞察、创建可视化..."2. Level 2: 读取 SKILL.md → 学习基础分析方法 → 看到数据清洗脚本和报告生成脚本3. Level 3: 按需执行 → bash: python scripts/clean_data.py sales_2024.csv → 脚本代码不进入上下文，只有结果进入（~100 tokens） → bash: python scripts/generate_report.py cleaned.csv → 同样，只有报告摘要进入上下文Token 效率：- 传统方式（所有指令在 prompt）：~15,000 tokens- Skills 方式（渐进式）：~6,000 tokens- 效率提升：2.5 倍！
七、Skills 在各平台的使用
7.1 平台对比总览
| 平台 | 预构建 Skills | 自定义 Skills | 共享范围 | 网络访问 | 包安装 |
|---|---|---|---|---|---|
| Claude API | ✅ 4个 | ✅ 文件系统 | 组织级 | ❌ 无 | 仅预装 |
| Claude Code | ❌ | ✅ 文件系统 | 个人/项目 | ✅ 完全 | 本地 |
| Agent SDK | ❌ | ✅ 文件系统 | 个人/项目 | 取决于配置 | 取决于环境 |
| Claude.ai | ✅ 4个 | ✅ ZIP上传 | 个人 | 取决于设置 | N/A |
7.2 Claude API
from anthropic import Anthropicclient = Anthropic()# 上传 Skillskill = client.skills.create(skill_dir="/path/to/my-skill")# 使用response = client.messages.create( tools=[{"type": "code_execution", "container_id": skill.id}], messages=[...])# 列表和删除skills = client.skills.list()client.skills.delete(skill.id)
八、Skill 设计最佳实践
8.1 编写清晰的 Description
❌ 不好：description: PDF processing tool
✅ 好：
description: ExtracttextandtablesfromPDFfiles,fillforms,mergedocuments.UsewhenworkingwithPDFfilesorwhentheusermentionsPDFs,forms,ordocumentextraction.
8.2 渐进式披露指令
❌ 不好：把所有内容塞进 SKILL.md
✅ 好：主指令 + 链接到详细文档
8.3 使用脚本处理复杂逻辑
❌ 不好：让 Claude 生成复杂代码
✅ 好：提供预制脚本
8.4 单一职责原则
每个 Skill 专注一个领域
九、安全考虑 ⚠️
核心原则
只使用可信来源的 Skills：
- ✅ 你自己创建的
- ✅ Anthropic 官方的
- ❌ 未知来源的
审查清单
# 列出所有文件find skill/ -type f# 查找可疑内容grep -r "http://" skill/grep -r "subprocess" skill/
十、总结
10.1 Skills 的核心价值
| 价值 | 说明 | 效果 |
|---|---|---|
| 🎯 按需加载 | 渐进式披露，不一次性加载 | Token 效率 3-10 倍 |
| 🧠 第一性原理 | 回到本质，重新设计 | 突破性创新 |
| 📦 模块化 | 每个 Skill 独立封装领域 | 易维护、可复用 |
| 🔧 可组合 | 多个 Skills 协同工作 | 复杂能力简单组合 |
| 📁 无限扩展 | 文件系统存储，未用不消耗 | 可包含任意多资料 |
| ⚡ 脚本高效 | 代码不进入上下文，只要输出 | 确定性 + 零 token |
10.2 核心洞察
Skills vs Tools 不是量的差别，是质的差别！
- Tools = 函数调用接口
- Skills = 专家知识包（工具 + 知识 + 流程 + 经验）
就像：
- ❌ 给 Agent 一个工具箱
- ✅ 给 Agent 一个专业学位
如何学习大模型 AI ？
由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。
但是具体到个人，只能说是：
“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。
这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。
我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。
我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。
第一阶段（10天）：初阶应用
该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。
- 大模型 AI 能干什么？
- 大模型是怎样获得「智能」的？
- 用好 AI 的核心心法
- 大模型应用业务架构
- 大模型应用技术架构
- 代码示例：向 GPT-3.5 灌入新知识
- 提示工程的意义和核心思想
- Prompt 典型构成
- 指令调优方法论
- 思维链和思维树
- Prompt 攻击和防范
- …
第二阶段（30天）：高阶应用
该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。
- 为什么要做 RAG
- 搭建一个简单的 ChatPDF
- 检索的基础概念
- 什么是向量表示（Embeddings）
- 向量数据库与向量检索
- 基于向量检索的 RAG
- 搭建 RAG 系统的扩展知识
- 混合检索与 RAG-Fusion 简介
- 向量模型本地部署
- …
第三阶段（30天）：模型训练
恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。
到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？
- 为什么要做 RAG
- 什么是模型
- 什么是模型训练
- 求解器 & 损失函数简介
- 小实验2：手写一个简单的神经网络并训练它
- 什么是训练/预训练/微调/轻量化微调
- Transformer结构简介
- 轻量化微调
- 实验数据集的构建
- …
第四阶段（20天）：商业闭环
对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。
- 硬件选型
- 带你了解全球大模型
- 使用国产大模型服务
- 搭建 OpenAI 代理
- 热身：基于阿里云 PAI 部署 Stable Diffusion
- 在本地计算机运行大模型
- 大模型的私有化部署
- 基于 vLLM 部署大模型
- 案例：如何优雅地在阿里云私有部署开源大模型
- 部署一套开源 LLM 项目
- 内容安全
- 互联网信息服务算法备案
- …
学习是一个过程，只要学习就会有挑战。天道酬勤，你越努力，就会成为越优秀的自己。
如果你能在15天内完成所有的任务，那你堪称天才。然而，如果你能完成 60-70% 的内容，你就已经开始具备成为一名大模型 AI 的正确特征了。
这份完整版的大模型 AI 学习资料已经上传优快云，朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】
350
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
