上篇回顾：我们深入理解了Skills的三层渐进式加载机制
本篇目标：真正动手，从零构建一个可用的Skill
下篇预告：将Skill工程化，用于生产环境

引言：从理论到实践的第一步

上一篇我们理解了Skills的设计哲学：

• 三层渐进式加载
• Filesystem架构
• 混合执行模式

现在，该动手了。

作为一个技术负责人，我的哲学是：理解原理很重要，但能用才是王道。

这篇教程会带你：

1. 创建最简单的Hello World Skill
2. 构建一个实用的代码审查助手
3. 添加工具脚本体验混合执行
4. 解决常见问题

不讲虚的，只讲实的。每一步都有具体代码。

第一部分：环境准备

1.1 选择合适的平台

在开始之前，你需要选择在哪个平台上开发Skills。

三个选项对比：

我的建议：

第一次学习：用 Claude Code
- 最灵活
- 调试方便
- 所见即所得

生产环境：用 Claude API
- 可编程
- 团队协作
- 稳定可靠

快速体验：用 Claude.ai
- 无需安装
- 立即可用
- 但功能有限

本教程基于Claude Code，因为它最适合学习和开发。

1.2 Claude Code的安装和配置

安装Claude Code（如果你还没有）：

# macOS/Linux
# 从Anthropic官网下载并安装
# https://www.anthropic.com/claude-code

# 验证安装
claude-code --version

配置Skills目录：

Claude Code会在两个地方查找Skills：

# 1. 个人Skills（全局）
~/.claude/skills/

# 2. 项目Skills（当前项目）
.claude/skills/

创建第一个Skills目录：

# 创建个人Skills目录
mkdir -p ~/.claude/skills/

# 或者项目Skills目录（在你的项目根目录）
mkdir -p .claude/skills/

目录结构：

~/.claude/skills/
├── hello-world/         # 我们第一个Skill
├── code-review/         # 代码审查助手
└── (更多Skills...)

1.3 验证环境

创建一个测试文件：

# 创建测试目录
mkdir -p ~/.claude/skills/test-skill/

# 创建SKILL.md
cat > ~/.claude/skills/test-skill/SKILL.md << 'EOF'
---
name: 测试Skill
description: 用于验证Skills环境配置正确。当用户说"测试skill"时使用。
---

# 测试Skill

如果你看到这条消息，说明Skills环境配置成功！
EOF

在Claude Code中测试：

打开Claude Code
输入："测试skill"

如果Claude回复提到"Skills环境配置成功"
→ 说明环境OK，可以继续

如果没有反应：
→ 检查Skills目录是否正确
→ 检查SKILL.md格式是否正确

第二部分：Hello World Skill

2.1 最简单的Skill

让我们从最简单的开始：一个问候Skill。

创建目录结构：

mkdir -p ~/.claude/skills/hello-world/
cd ~/.claude/skills/hello-world/

编写SKILL.md：

---
name: Hello World
description: 一个简单的问候助手。当用户说hello、你好、hi时使用。
---

# Hello World Skill

## 功能
向用户问候，并介绍自己

## 使用方法
当检测到问候语时，回复：

🎉 **你好！我是你的AI助手Claude。**

很高兴见到你！今天我能帮你做什么？

## 限制
- 只在明确的问候场景使用
- 不用于其他对话

就这么简单！

2.2 测试Hello World

在Claude Code中测试：

输入："hello"

期望输出：
🎉 你好！我是你的AI助手Claude。
很高兴见到你！今天我能帮你做什么？

如果没有触发：

检查清单：

□ SKILL.md文件在正确的位置？
  ~/.claude/skills/hello-world/SKILL.md

□ YAML frontmatter格式正确？
  ---
  name: Hello World
  description: ...
  ---
  （注意：三个横杠，YAML格式）

□ description包含触发词？
  "当用户说hello、你好、hi时使用"

□ 重启Claude Code？
  有时需要重启才能识别新Skill

2.3 理解触发机制

关键在description：

---
description: 一个简单的问候助手。当用户说hello、你好、hi时使用。
---

这一句话决定了：

• 什么时候触发这个Skill
• Claude如何匹配用户输入

好的description：

# ✅ 清晰明确
description: 审查Go/Python代码，检查规范、安全、性能。当用户提供代码diff或要求code review时使用。

# ✅ 包含触发关键词
description: 生成技术文档。当用户说"写文档"、"生成文档"或提供代码需要文档化时使用。

# ✅ 说明使用场景
description: 分析机器人故障日志。当用户上传.log文件或提到"故障"、"error"、"异常"时使用。

差的description：

# ❌ 太模糊
description: 帮助用户

# ❌ 没有触发条件
description: 一个很有用的助手

# ❌ 过于宽泛
description: 处理所有编程相关的问题

2.4 迭代改进Hello World

版本2：添加更多细节

---
name: Hello World
description: 友好的问候助手。当用户首次打招呼（hello、hi、你好、嗨）时使用。
---

# Hello World Skill

## 问候模板

根据时间和场景，使用不同的问候：

### 首次见面
🎉 **你好！我是Claude，你的AI编程助手。**

我擅长：
- 代码审查和优化
- 技术方案设计
- 问题分析和解决

今天想聊什么？

### 再次见面
👋 **欢迎回来！**

上次我们聊到了[之前的话题]，有什么新的需求吗？

## 使用原则
- 保持友好和专业
- 提供明确的能力范围
- 引导下一步对话

测试版本2：

输入："你好"

观察：
- 是否使用了新的问候模板？
- 是否提到了擅长的领域？
- 是否引导了下一步对话？

第三部分：实用Skill – 代码审查助手（Level 1+2）

现在我们构建一个真正有用的Skill：代码审查助手。

3.1 设计Skill结构

第一步：明确需求

目标：帮助审查Go和Python代码
检查内容：
- 编码规范
- 常见错误
- 安全问题
- 性能问题
- 最佳实践

输入：代码diff或完整代码
输出：结构化的审查报告

第二步：设计目录结构

code-review/
├── SKILL.md              # 主要指令（Level 2）
├── docs/                 # 详细指南（Level 3）
│   ├── go-guide.md
│   └── python-guide.md
└── examples/             # 示例（Level 3）
    └── review-example.md

3.2 编写SKILL.md（核心指令）

---
name: 代码审查助手
description: 审查Go和Python代码，检查规范、安全、性能、最佳实践。当用户提供代码diff、请求code review或提到"审查代码"时使用。
---

# 代码审查助手

## 审查流程

### 第一步：识别上下文
1. 确定编程语言（Go/Python）
2. 理解代码的目的和功能
3. 识别变更的范围

### 第二步：规范检查

#### Go代码规范
- 命名：使用驼峰命名，导出符号首字母大写
- 错误处理：不要忽略error返回值
- 格式：是否符合gofmt标准
- 注释：导出函数必须有文档注释

参考详细规范：查看 <code>docs/go-guide.md</code>

#### Python代码规范
- 命名：遵循PEP 8，使用snake_case
- 类型提示：建议使用类型注解
- 文档字符串：使用docstring
- 格式：遵循black/autopep8风格

参考详细规范：查看 <code>docs/python-guide.md</code>

### 第三步：安全检查

**常见安全问题**：
1. SQL注入：是否直接拼接SQL语句？
2. XSS：是否正确转义HTML输出？
3. 硬编码密钥：是否有API key、密码等敏感信息？
4. 路径遍历：文件路径是否经过验证？
5. 命令注入：是否直接执行用户输入？

### 第四步：性能检查

**性能问题清单**：
- 是否有N+1查询？
- 循环中是否有重复计算？
- 是否正确使用了缓存？
- 大数据处理是否高效？
- 是否有不必要的内存拷贝？

### 第五步：最佳实践

**Go最佳实践**：
- 使用defer释放资源
- 避免goroutine泄漏
- 正确使用context
- 合理的并发控制

**Python最佳实践**：
- 使用上下文管理器（with语句）
- 列表推导式优于循环
- 生成器处理大数据
- 避免可变默认参数

### 第六步：生成报告

## 输出格式

```markdown
# 代码审查报告

## 📋 概述
- 语言：[Go/Python]
- 文件数：[N]
- 代码行数：[N]

## 🔴 关键问题（必须修改）
1. [问题描述]
   - 位置：[文件名:行号]
   - 原因：[为什么是问题]
   - 建议：[如何修改]

## 🟡 建议改进（可选优化）
1. [改进建议]
   - 位置：[文件名:行号]
   - 说明：[为什么建议改进]
   - 示例：[更好的写法]

## 🟢 优点（做得好的地方）
1. [值得肯定的地方]

## 📊 总体评价
- 代码质量：[优秀/良好/一般/需改进]
- 安全性：[安全/有风险/高风险]
- 性能：[优秀/良好/需优化]
- 可维护性：[高/中/低]

## 💡 总结建议
[综合建议，3-5条]</code></pre>
<h2>示例</h2>
<p>参考 <code>examples/review-example.md</code> 查看完整审查示例。</p>
<h2>限制</h2>
<ul>
<li>只做静态分析，不执行代码</li>
<li>对业务逻辑的判断仅供参考</li>
<li>复杂的算法分析可能不准确
<pre><code></code></pre></li>
</ul>
<h3>3.3 添加详细指南（Level 3）</h3>
<p><strong>创建go-guide.md</strong>：</p>
<pre><code class="language-bash">cat > ~/.claude/skills/code-review/docs/go-guide.md << 'EOF'
# Go代码审查详细指南

## 命名规范

### 变量命名
- 局部变量：简短（i, j, idx）
- 导出变量：清晰描述（UserManager, DatabaseConfig）
- 避免：snake_case（这是Python的）

### 函数命名
- 动词开头（GetUser, CreateOrder）
- 导出函数：首字母大写
- 私有函数：首字母小写

## 错误处理

### ✅ 正确做法
```go
result, err := SomeFunction()
if err != nil {
    return fmt.Errorf("failed to do something: %w", err)
}

❌ 错误做法

result, _ := SomeFunction()  // 忽略错误！

并发安全

常见问题

1. 数据竞争（data race）
2. goroutine泄漏
3. channel死锁

检查要点

• map并发读写是否加锁？
• goroutine是否正确退出？
• channel是否会阻塞？

资源管理

使用defer

file, err := os.Open("file.txt")
if err != nil {
    return err
}
defer file.Close()  // ✅ 确保关闭

性能优化

避免不必要的分配

// ❌ 每次循环都分配
for i := 0; i < 1000; i++ {
    s := fmt.Sprintf("item %d", i)
}

// ✅ 复用buffer
var buf strings.Builder
for i := 0; i < 1000; i++ {
    buf.Reset()
    buf.WriteString("item ")
    buf.WriteString(strconv.Itoa(i))
}

测试

检查要点

• 是否有测试？
• 测试覆盖率如何？
• 是否测试了错误情况？
• 是否有benchmark？
  EOF

创建python-guide.md（类似结构）

创建review-example.md（审查示例）

3.4 测试代码审查助手

准备测试代码：

// test.go - 故意包含多个问题
package main

import "fmt"

func GetUser(id string) {  // 问题1：没有返回值，没有错误处理
    query := "SELECT * FROM users WHERE id=" + id  // 问题2：SQL注入
    result, _ := db.Query(query)  // 问题3：忽略错误
    fmt.Println(result)
}

var users = make(map[string]string)  // 问题4：并发不安全

func main() {
    GetUser("123")
}

在Claude Code中测试：

粘贴上面的代码
输入："请审查这段Go代码"

期望输出：
应该发现：
1. SQL注入风险
2. 错误处理缺失
3. map并发不安全
4. 函数设计不合理

验证效果：

✅ 检查是否发现了主要问题
✅ 检查是否给出了修改建议
✅ 检查报告格式是否清晰
✅ 检查是否提到了优点（如果有）

第四部分：添加工具脚本（Level 3 – 混合执行）

现在我们添加可执行代码，体验混合执行的威力。

4.1 为什么需要工具脚本？

纯指令的局限：

问题：检查代码的圈复杂度

纯指令方式：
- 让Claude数判断语句
- 可能数错
- 每次可能不同

工具脚本方式：
- Python脚本精确计算
- 结果确定
- 快速可靠

4.2 创建复杂度分析脚本

目录结构：

code-review/
├── SKILL.md
├── docs/
│   ├── go-guide.md
│   └── python-guide.md
├── tools/                    # 新增：工具脚本
│   ├── complexity.py         # 圈复杂度计算
│   └── security_check.py     # 安全检查
└── examples/
    └── review-example.md

创建complexity.py：

#!/usr/bin/env python3
"""
圈复杂度计算工具
计算代码的圈复杂度（Cyclomatic Complexity）
"""

import ast
import sys

def calculate_complexity(source_code, language='python'):
    """计算圈复杂度"""
    if language == 'python':
        return calculate_python_complexity(source_code)
    elif language == 'go':
        return calculate_go_complexity(source_code)
    else:
        return {"error": f"Unsupported language: {language}"}

def calculate_python_complexity(source_code):
    """计算Python代码的圈复杂度"""
    try:
        tree = ast.parse(source_code)

        functions = {}

        for node in ast.walk(tree):
            if isinstance(node, ast.FunctionDef):
                complexity = calculate_function_complexity(node)
                functions[node.name] = complexity

        total = sum(functions.values())
        avg = total / len(functions) if functions else 0

        return {
            "total_complexity": total,
            "average_complexity": round(avg, 2),
            "functions": functions,
            "assessment": assess_complexity(avg)
        }
    except SyntaxError as e:
        return {"error": f"Syntax error: {e}"}

def calculate_function_complexity(node):
    """计算单个函数的圈复杂度"""
    complexity = 1  # 基础复杂度

    for child in ast.walk(node):
        # 每个判断分支增加1
        if isinstance(child, (ast.If, ast.While, ast.For, ast.ExceptHandler)):
            complexity += 1
        # 每个逻辑运算符增加1
        elif isinstance(child, (ast.And, ast.Or)):
            complexity += 1

    return complexity

def calculate_go_complexity(source_code):
    """
    计算Go代码复杂度（简化版）
    实际项目中应该使用gocyclo工具
    """
    # 简化实现：数关键词
    keywords = ['if', 'for', 'case', '&&', '||']
    complexity = 1

    for keyword in keywords:
        complexity += source_code.count(keyword)

    return {
        "total_complexity": complexity,
        "note": "这是简化计算，建议使用gocyclo工具"
    }

def assess_complexity(complexity):
    """评估复杂度等级"""
    if complexity <= 5:
        return "简单 - 易于理解和维护"
    elif complexity <= 10:
        return "中等 - 较复杂，但可接受"
    elif complexity <= 20:
        return "复杂 - 建议重构"
    else:
        return "非常复杂 - 强烈建议重构"

def main():
    """命令行入口"""
    if len(sys.argv) < 2:
        print("Usage: python complexity.py <file> [language]")
        sys.exit(1)

    file_path = sys.argv[1]
    language = sys.argv[2] if len(sys.argv) > 2 else 'python'

    try:
        with open(file_path, 'r') as f:
            source_code = f.read()

        result = calculate_complexity(source_code, language)

        # 输出结果
        print("=" * 50)
        print("圈复杂度分析报告")
        print("=" * 50)

        if "error" in result:
            print(f"错误: {result['error']}")
        else:
            print(f"总复杂度: {result['total_complexity']}")
            print(f"平均复杂度: {result.get('average_complexity', 'N/A')}")
            print(f"评估: {result.get('assessment', 'N/A')}")

            if 'functions' in result:
                print("\n函数详情:")
                for func_name, complexity in result['functions'].items():
                    status = "✓" if complexity <= 10 else "⚠" if complexity <= 20 else "✗"
                    print(f"  {status} {func_name}: {complexity}")

    except FileNotFoundError:
        print(f"错误: 文件不存在 {file_path}")
        sys.exit(1)
    except Exception as e:
        print(f"错误: {e}")
        sys.exit(1)

if __name__ == "__main__":
    main()

测试脚本：

# 创建测试文件
cat > /tmp/test.py << 'EOF'
def simple_function(x):
    return x + 1

def complex_function(x, y):
    if x > 0:
        if y > 0:
            for i in range(10):
                if i % 2 == 0:
                    print(i)
    elif x < 0:
        while y > 0:
            y -= 1
    return x + y
EOF

# 运行分析
python ~/.claude/skills/code-review/tools/complexity.py /tmp/test.py

# 期望输出：
# ==================================================
# 圈复杂度分析报告
# ==================================================
# 总复杂度: 8
# 平均复杂度: 4.0
# 评估: 简单 - 易于理解和维护
#
# 函数详情:
#   ✓ simple_function: 1
#   ✓ complex_function: 7

4.3 在SKILL.md中使用脚本

更新SKILL.md：

### 第四步：复杂度分析

使用工具脚本分析代码复杂度：

```bash
python tools/complexity.py <文件路径> python</code></pre>
<p>根据分析结果：</p>
<ul>
<li>复杂度 > 10：建议重构，拆分函数</li>
<li>复杂度 > 20：必须重构，过于复杂</li>
<li>复杂度 <= 5：优秀，保持简洁</li>
</ul>
<p><strong>复杂度超标的处理建议</strong>：</p>
<ol>
<li>提取子函数</li>
<li>使用策略模式替代复杂if-else</li>
<li>使用表驱动法</li>
<li>简化嵌套逻辑
<pre><code></code></pre></li>
</ol>
<h3>4.4 测试混合执行</h3>
<p><strong>准备一个复杂的测试文件</strong>：</p>
<pre><code class="language-python"># complex_code.py
def process_order(order, user, payment):
    if order is None:
        return {"error": "No order"}

    if user is None:
        return {"error": "No user"}

    if payment is None:
        return {"error": "No payment"}

    if order.status == "pending":
        if user.is_verified:
            if payment.amount >= order.total:
                if payment.method == "credit_card":
                    if payment.card.is_valid():
                        for item in order.items:
                            if item.stock > 0:
                                item.stock -= 1
                            else:
                                return {"error": f"Out of stock: {item.name}"}
                        order.status = "confirmed"
                        return {"success": True}
                    else:
                        return {"error": "Invalid card"}
                else:
                    return {"error": "Unsupported payment method"}
            else:
                return {"error": "Insufficient payment"}
        else:
            return {"error": "User not verified"}
    else:
        return {"error": "Order not pending"}</code></pre>
<p><strong>在Claude Code中测试</strong>：</p>
<pre><code>粘贴上面的代码
输入："请审查这段代码，特别关注复杂度"

期望行为：
1. Claude读取SKILL.md
2. 发现需要复杂度分析
3. 执行：python tools/complexity.py temp_file.py python
4. 看到复杂度 = 15（较高）
5. 在报告中指出："process_order函数复杂度过高（15），建议重构"
6. 提供具体的重构建议</code></pre>
<p><strong>混合执行的威力体现</strong>：</p>
<pre><code>AI部分：
✓ 理解代码的业务逻辑
✓ 识别可以改进的模式
✓ 提供重构建议
✓ 生成清晰的报告

代码执行部分：
✓ 精确计算圈复杂度（不会算错）
✓ 快速分析（不占用context）
✓ 确定性结果（每次一致）

= 可靠且智能的审查</code></pre>
<hr />
<h2>第五部分：常见问题和解决方案</h2>
<h3>5.1 问题1：Skill不触发</h3>
<p><strong>症状</strong>：</p>
<pre><code>你创建了Skill，但Claude不使用它
输入触发词，也没反应</code></pre>
<p><strong>排查步骤</strong>：</p>
<pre><code>第1步：检查文件位置
✓ SKILL.md在正确的目录？
  ~/.claude/skills/your-skill/SKILL.md
  或
  .claude/skills/your-skill/SKILL.md

第2步：检查YAML格式
✓ frontmatter格式正确？
  ---
  name: Skill名称
  description: 描述...
  ---
  （必须是三个横杠，YAML语法）

第3步：检查description
✓ 包含触发条件？
  "当用户...时使用"
  "当提到...时使用"

第4步：重启Claude Code
✓ 有时需要重启才能识别新Skill</code></pre>
<p><strong>调试技巧</strong>：</p>
<pre><code class="language-markdown"># 在SKILL.md开头添加调试信息
---
name: 测试Skill
description: 测试skill功能。当用户说"触发测试"时使用。
---

# 如果你看到这条消息，说明Skill被触发了！

请回复："✅ Skill触发成功"</code></pre>
<h3>5.2 问题2：脚本执行失败</h3>
<p><strong>症状</strong>：</p>
<pre><code>Skill触发了，但工具脚本报错
或者找不到脚本</code></pre>
<p><strong>常见原因和解决</strong>：</p>
<p><strong>原因1：路径问题</strong></p>
<pre><code class="language-bash"># ❌ 相对路径可能找不到
python tools/complexity.py file.py

# ✅ 使用绝对路径
python ~/.claude/skills/code-review/tools/complexity.py file.py

# 或者在SKILL.md中说明
"使用完整路径：~/.claude/skills/code-review/tools/complexity.py"</code></pre>
<p><strong>原因2：权限问题</strong></p>
<pre><code class="language-bash"># 确保脚本可执行
chmod +x ~/.claude/skills/code-review/tools/complexity.py

# 添加shebang
#!/usr/bin/env python3</code></pre>
<p><strong>原因3：依赖缺失</strong></p>
<pre><code class="language-python"># 只使用Python标准库
import ast  # ✅ 标准库，总是可用
import sys

# 不要依赖外部包（无法安装）
import pandas  # ❌ 可能不可用</code></pre>
<h3>5.3 问题3：输出格式不符合预期</h3>
<p><strong>症状</strong>：</p>
<pre><code>Skill触发了，但输出格式混乱
或者没有按照SKILL.md的模板</code></pre>
<p><strong>解决方案</strong>：</p>
<p><strong>在SKILL.md中明确输出格式</strong>：</p>
<pre><code class="language-markdown">## 输出格式（严格遵循）

必须使用以下markdown格式：

```markdown
# 代码审查报告

## 🔴 关键问题
[问题列表]

## 🟡 建议改进
[改进列表]

## 📊 总体评价
[评价内容]

不要使用其他格式！

**添加格式示例**：

```markdown
## 输出示例

参考以下示例格式：

```markdown
# 代码审查报告

## 🔴 关键问题
1. SQL注入风险
   - 位置：main.go:15
   - 原因：直接拼接SQL语句
   - 建议：使用参数化查询

## 🟡 建议改进
1. 函数复杂度高
   - 位置：process_order (complexity=15)
   - 建议：拆分为多个子函数

### 5.4 问题4：Skill冲突

**症状**：

有多个相似的Skills
不知道Claude会用哪个
或者同时触发多个

**解决方案1：精确的触发条件**

```yaml
# Skill A: 通用代码审查
---
name: 代码审查
description: 审查各种代码。当用户说"审查代码"但没有指定语言时使用。
---

# Skill B: Go代码专家
---
name: Go代码审查
description: 专门审查Go代码。当用户提到"Go"、".go文件"或明确说"审查go代码"时使用。优先级高于通用代码审查。
---</code></pre>
<p><strong>解决方案2：分工明确</strong></p>
<pre><code>code-review-general/    # 通用审查
go-expert/              # Go专家
python-expert/          # Python专家
security-scanner/       # 安全专项

每个Skill专注一个领域，避免重叠</code></pre>
<h3>5.5 问题5：调试困难</h3>
<p><strong>症状</strong>：</p>
<pre><code>不知道为什么Skill没触发
不知道执行到哪一步了
没有错误信息</code></pre>
<p><strong>解决方案：添加日志</strong></p>
<p>在工具脚本中：</p>
<pre><code class="language-python">import sys

def log(message):
    """输出到stderr（不会被当成结果）"""
    print(f"[DEBUG] {message}", file=sys.stderr)

def main():
    log("脚本开始执行")
    log(f"参数: {sys.argv}")

    try:
        result = process()
        log("处理成功")
        print(result)  # stdout是结果
    except Exception as e:
        log(f"错误: {e}")
        sys.exit(1)</code></pre>
<p>在SKILL.md中：</p>
<pre><code class="language-markdown">## 调试模式

如果需要调试，添加 --debug 标志：

```bash
python tools/complexity.py file.py --debug

这会输出详细的执行过程。

### 5.6 快速排错清单

```markdown
□ Skill文件位置正确？
□ YAML格式正确？（用linter检查）
□ description包含触发词？
□ 脚本路径正确？
□ 脚本有执行权限？
□ 只使用标准库？
□ 输出格式明确？
□ 测试过脚本独立运行？
□ 重启了Claude Code？
□ 查看了错误日志？</code></pre>
<hr />
<h2>第六部分：实战技巧</h2>
<h3>6.1 迭代开发的最佳节奏</h3>
<p><strong>不要一次做太多</strong>：</p>
<pre><code>❌ 错误做法：
第1天：设计复杂的Skill（200行SKILL.md + 10个脚本）
第2天：调试各种问题
第3天：放弃

✅ 正确做法：
第1天：最简版本（20行SKILL.md，0个脚本）→ 验证触发
第2天：添加详细指令（100行） → 验证输出
第3天：添加1个关键脚本 → 验证混合执行
第4天：迭代优化</code></pre>
<p><strong>每个版本都要能工作</strong>：</p>
<pre><code>v0.1: Hello World（能触发）
v0.2: 基础审查（有输出）
v0.3: 详细指令（输出规范）
v0.4: 添加脚本（混合执行）
v0.5: 优化完善（生产可用）</code></pre>
<h3>6.2 测试驱动开发</h3>
<p><strong>先准备测试用例</strong>：</p>
<pre><code class="language-markdown">## 测试用例

### 测试1：简单代码
输入：
```python
def add(a, b):
    return a + b

期望输出：

• 代码简单清晰
• 无明显问题
• 建议添加类型提示

测试2：有问题的代码

输入：

def get_user(id):
    query = "SELECT * FROM users WHERE id=" + id
    return db.execute(query)

期望输出：

• 必须指出SQL注入风险
• 必须建议使用参数化查询
• 必须标记为"关键问题"

用测试验证每个版本：

开发流程：
1. 写测试用例
2. 开发Skill
3. 运行测试
4. 修复问题
5. 重复2-4

6.3 文档即代码

把使用文档写在SKILL.md中：

## 使用指南

### 快速开始
粘贴代码，说"请审查"即可

### 高级用法
- 只检查安全：说"只检查安全问题"
- 只检查性能：说"分析性能"
- 详细分析：说"给出详细的审查报告"

### 示例对话

**用户**: 请审查这段Go代码
[粘贴代码]

**Claude**: [使用Skill生成报告]

**用户**: 复杂度15太高了，怎么重构？

**Claude**: [提供重构建议]

这样：

• 用户知道怎么用
• Claude知道怎么做
• 一举两得

6.4 版本管理技巧

使用Git管理Skills：

cd ~/.claude/skills/
git init
git add .
git commit -m "Initial commit"

# 创建分支测试新功能
git checkout -b feature/add-performance-check
# 开发...
# 测试通过后合并
git checkout main
git merge feature/add-performance-check

打标签标记版本：

git tag v0.1.0 -m "First working version"
git tag v0.2.0 -m "Added complexity analysis"
git tag v1.0.0 -m "Production ready"

使用.gitignore：

# .gitignore
*.pyc
__pycache__/
.DS_Store
*.log
test-files/

结论：从0到1的完整旅程

你现在会了什么？

经过这篇教程，你应该能够：

✅ 创建基础Skill

• 理解SKILL.md的结构
• 编写有效的description
• 测试Skill的触发

✅ 构建实用Skill

• 设计清晰的目录结构
• 编写详细的指令
• 组织Level 2和Level 3的内容

✅ 使用混合执行

• 编写工具脚本
• 在Skill中调用脚本
• 体验确定性+灵活性

✅ 调试和优化

• 排查常见问题
• 使用调试技巧
• 迭代改进Skill

从玩具到工具的路径

现在：你有一个能用的Skill
├── 能触发
├── 有输出
└── 解决了实际问题

下一步：工程化（下篇）
├── 性能优化
├── 团队协作
├── 监控和维护
└── 生产级质量

实践建议

建议1：立即动手

不要等"准备好了"再开始
现在就：
1. 创建一个Hello World Skill
2. 测试它
3. 迭代改进

建议2：从简单开始

你的第一个生产Skill应该：
- 解决一个小而明确的问题
- 不超过100行SKILL.md
- 最多1-2个工具脚本
- 能在1周内完成

例如：
- 生成特定格式的周报
- 检查配置文件格式
- 提取日志中的错误

建议3：记录过程

创建一个开发日志：
- 遇到了什么问题？
- 怎么解决的？
- 有什么心得？
- 下次怎么改进？

这会成为宝贵的经验

📚 系列文章

• 上篇：理解设计哲学 ✅
• 中篇：从零构建实践 ✅ 你刚读完
• 下篇：工程化落地 ⏭ 下一篇

💡 下一篇预告

《Claude Skills实战教程（三）：生产级Skills的工程化实践》

在下一篇中，我们将：

1. 性能优化：让Skills更快、更省资源
2. 团队协作：如何在团队中管理和共享Skills
3. 监控和可观测性：如何知道Skills运行得好不好
4. 高仙团队实战：我们团队的真实案例和经验
5. 进阶话题：Skills组合、版本管理、安全加固

从Demo到生产，这一步很关键。

敬请期待！

附录：完整示例代码

代码审查Skill完整版

所有示例代码已上传到GitHub：

https://github.com/yourusername/claude-skills-examples/code-review/

包含：

• 完整的SKILL.md
• 所有工具脚本
• 测试用例
• 使用文档

可以直接下载使用：

git clone https://github.com/yourusername/claude-skills-examples
cp -r code-review ~/.claude/skills/