Claude Skills 制作完整指南-制作分镜脚本Skill

深入讲解Claude Skills的每一个知识点，通过制作一个完整的分镜脚本Skill，从零基础到高级应用，一步一步由浅入深地掌握Skill开发的全流程。

NativeGG

1307人浏览 · 2026-01-30 00:15:29

NativeGG · 2026-01-30 00:15:29 发布

Claude Skills 制作完整指南：以分镜脚本Skill为例

文档目标：深入讲解Claude Skills的每一个知识点，通过制作一个完整的分镜脚本Skill，从零基础到高级应用，一步一步由浅入深地掌握Skill开发的全流程。

第一部分：Claude Skills 基础概念
第二部分：Skills的核心知识点体系
第三部分：分镜脚本Skill实战开发
第四部分：Skills与其他工具的对比
第五部分：高级特性和优化
第六部分：质量检查和安全性
第七部分：最佳实践和常见问题
第八部分：完整项目示例

第一部分：Claude Skills 基础概念

1.1 什么是Claude Skills？

Claude Skills是Anthropic为Claude AI模型设计的一套基于提示词的元工具架构。它允许开发者将特定领域的专业知识、工作流程和工具封装成独立的、可重复使用的"技能包"。

1.1.1 Skills的本质（关键理解）

重要澄清：Skills不是直接执行代码的工具，而是通过提示词扩展和上下文修改来改变Claude行为的元工具。

Skills本质上是一个文件夹，包含：

指令文档（SKILL.md）：通过提示词告诉Claude如何执行特定任务
脚本文件（scripts/）：可执行的代码，用于确定性任务（不进入上下文）
参考资源（references/）：补充知识和标准规范（按需加载到上下文）
资产文件（assets/）：模板、示例等静态资源（不进入上下文）

核心机制：

Skills通过提示词注入改变Claude的行为，而非通过算法路由
Claude使用纯LLM推理决定何时调用Skill，基于name和description字段
没有正则表达式、关键字匹配或机器学习意图检测
Skills修改的是对话上下文和执行上下文，而非直接执行操作

1.1.2 Skills与传统Prompt的区别

特性	传统Prompt	Claude Skills
复用性	每次需要重新输入	一次创建，永久使用
组织性	单一文本块	结构化文件夹
可维护性	难以更新	版本可控，易于迭代
专业性	通用指令	领域专业化
加载方式	全部加载	渐进式按需加载

1.1.3 Skills的核心优势

模块化设计：每个Skill专注于一个特定任务
渐进式加载：只在需要时加载相关内容，节省Token
可组合性：多个Skills可以协同工作
可移植性：Skill可以在不同项目间共享
专业化：将通用AI转化为领域专家

1.2 为什么选择分镜脚本Skill作为例子？

分镜脚本（Storyboard）是影视制作中的核心文档，它需要：

结构化思维：将故事分解为场景和镜头
专业术语：使用标准电影术语
多元素整合：场景、镜头、演员、音效、技术指导
格式规范：遵循行业标准格式
实用工具：需要验证、格式化、导出等功能

这个例子完美展示了Skills的所有核心知识点，包括：

元数据设计
指令编写
脚本开发
资源组织
质量保证

1.3 Skills的应用场景

Skills适用于以下场景：

重复性专业任务：如代码审查、文档生成、数据分析
领域特定工作流：如法律文档、医疗报告、工程设计
标准化流程：如测试用例生成、API文档编写
多步骤复杂任务：如项目规划、需求分析、架构设计

第二部分：Skills的核心知识点体系

2.1 知识点1：SKILL.md文件结构

SKILL.md是每个Skill的核心文件，也是唯一必需的文件。它采用特殊的格式，包含两个关键部分。

2.1.1 YAML前置元数据（Front Matter）

YAML前置元数据位于文件开头，用---包围，包含Skill的基本信息：

---
name: storyboard-generator
description: 根据剧本或创意概念生成专业分镜脚本，包含场景、镜头类型、运镜、演员指导和音效。用于电影、视频、广告制作。
dependencies: python>=3.8, pillow>=8.0
---

关键字段解析：

name字段（必需）
- 作用：Skill的人类友好名称
- 限制：最多64个字符
- 重要性：这个名称会转换为斜杠命令（如/storyboard-generator）
- 命名建议：
  - 使用小写字母和连字符
  - 简洁但描述性强
  - 避免特殊字符
- 示例：
  - ✅ storyboard-generator
  - ✅ code-reviewer
  - ❌ My Awesome Storyboard Skill!!!（太长且有特殊字符）
description字段（必需）
- 作用：Claude使用此信息判断何时调用该Skill（通过纯LLM推理，非算法匹配）
- 限制：最多200个字符
- 重要性：这是最重要的字段，直接影响Skill的触发准确性
- 关键要求：必须使用第三人称描述
- 编写原则：
  - ✅ 推荐措辞：“This skill should be used when…”（此技能应在…时使用）
  - ❌ 避免措辞：“Use this skill when…”（使用此技能当…）
  - 明确说明"做什么"和"何时使用"
  - 包含关键词，便于Claude理解匹配
  - 使用第三人称描述（这是官方要求）
- 示例对比：
  - ❌ “生成分镜脚本”（太模糊，缺少触发条件）
  - ❌ “当用户需要生成分镜脚本时使用此技能”（使用了"使用此技能"，不够自然）
  - ✅ “当用户需要为视频、电影或动画项目创建专业分镜脚本时使用此技能。提供结构化、可视化的拍摄指导，包含场景、镜头类型、运镜、演员指导和音效。”（第三人称，明确触发条件，包含关键词）
dependencies字段（可选）
- 作用：列出Skill所需的软件包
- 格式：package>=version, package2>=version2
- 支持：Python (PyPI)、JavaScript (npm)
- 注意：对于API Skills，所有依赖必须预先安装

2.1.2 Markdown正文内容

YAML元数据之后是Markdown格式的详细指令。这是Claude执行任务时的具体指导。

推荐结构：

# Purpose（目的）
说明Skill存在的目的和价值

# When to Use（何时使用）
明确列出应该使用此Skill的具体场景

# Process（流程）
1. 第一步：...
2. 第二步：...
...

# Decision Logic（决策逻辑）
- If 条件A，则执行X
- Else if 条件B，则执行Y
- Else 执行Z

# Tool Usage（工具使用）
说明需要调用的脚本和工具

# Inputs Needed（所需输入）
列出所有必需的输入信息

# Outputs（输出）
描述输出的格式和内容

# Quality Checklist（质量检查清单）
- [ ] 检查项1
- [ ] 检查项2
...

2.2 知识点2：渐进式加载机制

这是Claude Skills最核心的设计理念。

2.2.1 三级加载架构

第一级：元数据（始终加载）
├─ name + description
├─ 约100-200词
└─ Claude据此判断是否需要该Skill

    ↓（当Skill被触发时）

第二级：SKILL.md正文（按需加载）
├─ 完整的工作流指导
├─ 建议<5000词
└─ 包含所有执行步骤

    ↓（当需要执行代码或查阅资源时）

第三级：打包资源（按需加载）
├─ scripts/（脚本文件）
├─ references/（参考文档）
├─ assets/（资产文件）
└─ 理论上可以无限大

2.2.2 渐进式加载的优势

性能优化：避免一次性加载所有内容
Token节省：只在需要时加载详细信息（节省93%以上Token）
快速决策：Claude可以快速判断是否需要某个Skill
可扩展性：支持大量Skills共存而不影响性能

2.2.4 Skills的决策机制（关键技术细节）

重要理解：Claude使用纯LLM推理决定何时调用Skill，而非算法路由。

决策过程：

元数据匹配：Claude读取所有Skills的name和description
语义理解：基于用户请求的语义，理解用户意图
推理匹配：在transformer前向传递中，推理哪个Skill最相关
触发调用：如果匹配，加载SKILL.md并执行工作流

关键特点：

❌ 没有正则表达式匹配
❌ 没有关键字搜索
❌ 没有机器学习意图分类器
✅ 只有基于语言理解的推理

这意味着：

description的质量直接影响Skill的可用性
必须使用自然语言描述，而非技术术语
需要包含触发场景的关键词
第三人称描述更符合Claude的理解模式

实际案例（分镜脚本Skill）：

用户说："帮我为广告创建分镜脚本"

Claude看到的元数据：
  name: storyboard-generator
  description: 当用户需要为视频、电影...创建专业分镜脚本时使用此技能...

Claude的推理过程：
  1. 理解用户意图：需要创建分镜脚本
  2. 匹配关键词：分镜脚本、广告（属于视频项目）
  3. 推理结果：storyboard-generator技能相关
  4. 决策：调用此技能

2.2.3 实际应用示例和Token成本分析

假设Claude有100个Skills：

传统方式（全部加载）：

需要加载所有100个Skills的完整内容
每个Skill约3000 tokens（SKILL.md + 资源）
总消耗：300,000 tokens
响应速度慢，成本极高

渐进式加载（Skills架构）：

第一级（常驻）：100个Skills的元数据
- 每个Skill约50-100 tokens（name + description）
- 总消耗：5,000-10,000 tokens（常驻）
第二级（触发时）：1-2个相关Skill的SKILL.md
- 每个约2,000-3,000 tokens
- 总消耗：2,000-6,000 tokens
第三级（按需）：references/中的文档
- 只在Claude需要查阅时加载
- 每次加载约1,000-5,000 tokens
总Token消耗：约8,000-21,000 tokens（相比传统方式节省93%以上）

实际案例（分镜脚本Skill）：

元数据加载：~80 tokens（常驻）
SKILL.md加载：~2,500 tokens（触发时）
references/加载：~3,000 tokens（按需，如查阅相机运动指南）
总成本：~5,580 tokens（相比一次性加载所有内容节省约80%）

2.3 知识点3：文件夹结构规范

标准的Skill文件夹结构如下：

skill-name/
├── SKILL.md              # 必需：核心指令文件
├── scripts/              # 可选：可执行脚本
│   ├── __init__.py
│   ├── process.py
│   └── helper.js
├── references/           # 可选：参考文档
│   ├── standards.md
│   └── examples.md
├── assets/               # 可选：静态资源
│   ├── templates/
│   └── examples/
├── tests/                # 可选：测试文件
│   └── test_skill.py
└── LICENSE               # 推荐：许可证文件

2.3.1 各文件夹的作用和职责边界（关键区分）

重要原则：不同文件夹的内容是否进入Claude的上下文，决定了它们的使用方式和优化策略。

文件夹	是否进入上下文	加载时机	使用场景	Token成本
scripts/	❌ 否	直接执行	确定性、重复性任务	0（不消耗上下文Token）
references/	✅ 是	按需加载	Claude需要查阅的文档	按实际加载量计算
assets/	❌ 否	直接引用	输出中使用的文件	0（不消耗上下文Token）

scripts/：包含可执行的代码文件
- Python脚本（.py）、JavaScript脚本（.js）、Shell脚本（.sh）
- 关键特点：代码不进入上下文，直接执行
- 优势：节省Token，执行确定性强，避免Claude重复生成相同代码
- 适用场景：
  - 重复性任务（如镜头编号生成、时间计算）
  - 确定性处理（如格式验证、数据转换）
  - 复杂计算（如时长统计、成本估算）
- 示例：scripts/validate_storyboard.py、scripts/calculate_duration.py
references/：补充知识和参考信息
- Markdown文档
- 关键特点：文档会进入上下文，但按需加载
- 最佳实践：
  - 文档>10k字时，必须在references/中，而非SKILL.md
  - 在SKILL.md中提供搜索提示，而非全部嵌入
  - 按主题拆分，便于Claude按需查阅
- 适用场景：
  - 详细规范（如电影术语标准）
  - 术语表（如镜头类型完整列表）
  - 最佳实践指南（如分镜脚本行业标准）
- 示例：references/storyboard_standards.md、references/camera_movements.md
assets/：不会加载到上下文的静态资源
- 模板文件（.docx, .xlsx, .pptx）
- 示例文件（.pdf, .md）
- 图标和图片（.svg, .png）
- 关键特点：完全不进入上下文，作为输出的一部分或参考
- 用途：
  - 作为输出的一部分（如使用模板生成Word文档）
  - 作为参考文件供用户下载
  - 作为模板供用户使用
- 示例：assets/templates/storyboard_template.docx
tests/：测试文件
- 单元测试、集成测试
- 用途：确保Skill质量
- 注意：测试文件不会被打包到Skill中，仅用于开发阶段

2.4 知识点4：脚本（Scripts）的使用

2.4.1 何时需要脚本？

脚本适用于以下场景：

确定性任务：需要精确、可重复的结果
复杂计算：涉及大量数据处理
格式转换：需要特定的输出格式
数据验证：检查输入输出的完整性
外部集成：调用API、访问数据库

2.4.2 脚本的优势

节省Token：代码不需要进入上下文
确定性：每次执行结果一致
可维护性：代码可以独立更新
可测试性：可以单独测试脚本

2.4.3 脚本编写最佳实践

#!/usr/bin/env python3
"""
脚本说明：这个脚本做什么
作者：...
版本：1.0.0
"""

import sys
import json
from typing import Dict, List

def main(input_data: Dict) -> Dict:
    """
    主处理函数
    
    Args:
        input_data: 输入数据字典
        
    Returns:
        处理后的数据字典
    """
    try:
        # 参数验证
        if not input_data:
            raise ValueError("输入数据不能为空")
        
        # 处理逻辑
        result = process_data(input_data)
        
        # 返回结果
        return {
            "success": True,
            "data": result
        }
    except Exception as e:
        return {
            "success": False,
            "error": str(e)
        }

def process_data(data: Dict) -> Dict:
    """实际处理函数"""
    # 实现具体逻辑
    pass

if __name__ == "__main__":
    # 命令行入口
    input_json = sys.stdin.read()
    input_data = json.loads(input_json)
    result = main(input_data)
    print(json.dumps(result, ensure_ascii=False, indent=2))

2.5 知识点5：参考文档（References）的组织

2.5.1 参考文档的作用

参考文档用于：

存储详细的知识库
提供术语和标准定义
包含最佳实践指南
提供示例和案例

2.5.2 文档组织原则

按主题拆分：不要把所有内容放在一个文件
清晰的命名：文件名应该描述内容
目录结构：使用标题层级组织内容
交叉引用：在SKILL.md中引用参考文档

2.5.3 参考文档示例结构

# 分镜脚本标准参考

## 目录
1. [镜头类型](#镜头类型)
2. [相机运动](#相机运动)
3. [场景编码](#场景编码)
4. [音效设计](#音效设计)

## 镜头类型

### 广角镜头 (Wide Shot)
- 定义：...
- 用途：...
- 示例：...

...

2.6 知识点6：资产文件（Assets）的管理

2.6.1 资产文件的类型

模板文件：Word、Excel、PowerPoint模板
示例文件：PDF示例、参考文档
图标和图片：SVG、PNG图标
配置文件：JSON、YAML配置

2.6.2 资产文件的使用

资产文件不会被加载到Claude的上下文中，而是：

作为输出的一部分
作为参考文件供用户下载
作为模板供用户使用

第三部分：分镜脚本Skill实战开发

现在我们将一步一步创建一个完整的分镜脚本Skill，涵盖所有知识点。

3.1 官方推荐的六步创建流程

根据Claude Skills官方最佳实践，创建Skill应遵循以下六个步骤。我们将通过分镜脚本Skill完整演示每一步。

步骤1：通过实例理解Skill

重要性：这是最容易被忽略但最关键的一步。即使维护既有Skill，也需要重新审视实例。

对于分镜脚本Skill，我们需要收集：

真实场景：
- 广告公司接到客户需求，48小时内需要30秒广告分镜脚本
- 独立电影制作人有10页剧本，需要快速可视化
- 学生需要为5分钟毕业作品制作分镜脚本
输入输出示例：
- 输入：创意简报、剧本文本、概念描述
- 输出：标准格式分镜脚本、镜头清单、技术规格表
成功标准：
- 分镜脚本包含所有必需元素（场景、镜头、技术说明）
- 使用标准电影术语
- 格式符合行业规范
- 可以直接用于制作筹备
常见失败情况：
- 缺少关键镜头
- 使用非标准术语
- 技术说明不完整
- 格式不规范
数据来源：
- 电影制作标准（好莱坞、中国、日本等）
- 行业术语库
- 实际项目案例

步骤2：确定Skill范围

目标与价值：

目标：快速将文字剧本转化为可执行的视觉指导
价值：节省制片筹备时间30-50%
针对用户：导演、制片主任、摄影师、学生

覆盖范围：

✅ 支持的输入：完整剧本、概念描述、片段对话
✅ 支持的媒体类型：电影、电视剧、广告、MV、纪录片
✅ 输出格式：JSON、Markdown、Word
❌ 明确边界：
- 不包含：实际视频生成、3D预览、预算计算、拍摄日程安排
- 限制：不处理超过100场景的长篇幅内容

依赖工具/数据源：

需要的库：Python处理文本（python>=3.8）
外部API：无
数据库连接：无

权限与安全：

数据隐私：不存储用户剧本内容
版权考量：生成的分镜归用户所有
使用限制：无特殊限制

3.2 第三步：结构化SKILL.md

3.2.1 编写YAML元数据（修正版）

目标：创建一个Skill，能够将文字剧本或创意概念转换为专业的分镜脚本。

核心功能：

分析输入内容（剧本、概念、片段）
识别关键场景和情节点
为每个场景生成多个镜头
使用标准电影术语
包含完整的技术指导
输出标准格式的分镜脚本

用户场景：

广告公司需要快速制作商业分镜
独立电影制作人需要将剧本可视化
学生需要为作业制作分镜脚本
制片团队需要标准化的分镜文档

3.1.2 功能范围定义

包含的功能：

✅ 场景分解和编号
✅ 镜头类型和角度设计
✅ 相机运动指导
✅ 演员动作描述
✅ 对白标注
✅ 音效和音乐指导
✅ 技术说明（灯光、特效）
✅ 格式验证
✅ 多格式导出（JSON、Markdown、Word）

不包含的功能：

❌ 实际视频生成
❌ 3D预览
❌ 预算计算
❌ 拍摄日程安排

3.2 第二步：创建SKILL.md文件

3.2.1 编写YAML元数据

---
name: storyboard-generator
description: 当用户需要为视频、电影、电视剧、广告或动画项目创建专业分镜脚本时使用此技能。根据剧本或创意概念生成结构化、可视化的拍摄指导，包含场景、镜头类型、运镜、演员指导和音效设计。
dependencies: python>=3.8
---

设计思路（关键修正）：

name：简洁、描述性，使用小写字母和连字符（最多64字符）
description（修正）：
- ✅ 必须使用第三人称：“当用户需要…时使用此技能”
- ✅ 明确说明触发条件：“为视频、电影…项目创建专业分镜脚本”
- ✅ 包含关键词：分镜脚本、剧本、场景、镜头类型
- ✅ 说明输出内容：结构化、可视化的拍摄指导
- ❌ 避免：“使用此技能当…”（不够自然）
dependencies：列出必需的Python版本（可选字段）

3.2.2 编写Markdown指令正文

# 分镜脚本生成器

## Purpose（目的）

该Skill将文字剧本、创意概念或场景描述转换为专业的分镜脚本文档。分镜脚本是影视制作中的核心文档，它将叙事视觉化，为导演、摄影师、灯光师、美术指导等制作团队成员提供明确的视觉指导。

## When to Use（何时使用）

使用此Skill当用户：
- 需要将剧本转换为分镜脚本
- 有创意概念需要可视化
- 需要为视频项目制作拍摄计划
- 想要理解电影视觉语言
- 需要标准化的分镜脚本格式

## Core Elements（核心元素）

生成的分镜脚本必须包含以下元素：

### 1. 场景标题和编号
格式：`SCENE [编号]: [INT/EXT] [地点] - [时间]`
- INT = 内景（Interior）
- EXT = 外景（Exterior）
- 时间：DAY（日）、NIGHT（夜）、DAWN（黎明）、DUSK（黄昏）

### 2. 场景描述（Scene Description）
- 简洁描述设置和环境
- 包括时间、地点、天气、氛围
- 字数：50-150字

### 3. 镜头类型（Shot Type）
必须使用标准电影术语：
- **Wide Shot (WS)**：广角镜头，显示整个场景
- **Medium Shot (MS)**：中景，从腰部到头部
- **Close-up (CU)**：特写，强调面部或细节
- **Extreme Close-up (ECU)**：极特写，极端细节
- **High Angle**：俯视镜头
- **Low Angle**：仰视镜头
- **Over-the-Shoulder (OTS)**：过肩镜头
- **Point of View (POV)**：主观镜头

### 4. 相机运动（Camera Movement）
- **Dolly In**：推进
- **Dolly Out**：拉出
- **Pan**：左右摇镜头
- **Tilt**：上下俯仰
- **Tracking**：跟拍
- **Crane**：升降
- **Zoom**：变焦
- **Static**：静止

### 5. 演员动作（Action）
- 详细描述角色的动作和肢体语言
- 包括对象互动
- 使用电影化语言

### 6. 对白（Dialogue）
- 直接转录或改编对白
- 标注说话者
- 包括语调标注（如：WHISPERED、SHOUTED）

### 7. 音效设计（Sound Design）
- **Ambient**：环境音
- **Sound Effects**：音效
- **Music**：背景音乐
- 标注音量和持续时间

### 8. 技术说明（Technical Notes）
- 灯光要求
- 特效需求
- 特殊设备
- 色彩和色调

## Process（工作流程）

当收到生成分镜脚本的请求时，遵循以下步骤：

### 第1步：分析输入内容
1. 识别输入类型（完整剧本、概念描述、片段）
2. 提取关键信息：
   - 故事的主要场景
   - 关键情节点和转折
   - 人物关系和动态
   - 时间线和地点变化
3. 理解叙事节奏和情感弧线

### 第2步：规划视觉结构
1. 将故事分解为场景单元
2. 为每个场景设计镜头序列
3. 考虑：
   - 视觉连贯性
   - 节奏和剪辑点
   - 情感强调点
   - 技术可行性

### 第3步：生成分镜脚本
1. 为每个场景创建场景标题
2. 为每个关键时刻设计3-5个镜头
3. 为每个镜头填写：
   - 镜头编号
   - 镜头类型
   - 相机运动
   - 场景描述
   - 演员动作
   - 对白（如有）
   - 音效指导
   - 技术说明

### 第4步：优化和验证
1. 检查时间连贯性
2. 验证镜头过渡的流畅性
3. 确保使用专业术语
4. 检查完整性（所有必需元素）
5. 使用 `scripts/validate_storyboard.py` 进行验证

### 第5步：格式化输出
1. 按照标准格式组织内容
2. 添加场景分隔符
3. 确保编号连续性
4. 生成最终文档

## Decision Logic（决策逻辑）

### 输入类型判断

**IF** 输入是完整的剧本脚本 **THEN**：
- 按照场景自然分割
- 将每条对话划分为独立镜头
- 在关键动作点插入特写或反应镜头
- 标注所有舞台指示

**ELSE IF** 输入是概念描述 **THEN**：
- 从关键视觉意象推导镜头设计
- 推荐适合的摄像机运动
- 提出场景转换的镜头建议
- 询问用户补充细节

**ELSE IF** 输入只有片段内容 **THEN**：
- 要求用户提供更多上下文
- 根据现有信息生成框架性分镜
- 保留填空处以待补充

### 镜头数量决策

**IF** 目标时长 ≤ 30秒 **THEN**：
- 生成5-8个镜头
- 平均每个镜头3-4秒

**ELSE IF** 目标时长 ≤ 2分钟 **THEN**：
- 生成10-20个镜头
- 平均每个镜头3-6秒

**ELSE IF** 目标时长 > 2分钟 **THEN**：
- 生成20+个镜头
- 根据场景复杂度调整

### 风格决策

**IF** 用户指定风格（如：动作、悬疑、浪漫） **THEN**：
- 调整镜头类型选择（动作片多用动态镜头）
- 调整相机运动（悬疑片多用特写和推进）
- 调整音效设计（浪漫片多用柔和音乐）

**ELSE**：
- 使用通用、平衡的镜头设计

## Tool Usage（工具使用）

### 脚本工具

1. **scripts/validate_storyboard.py**
   - 验证分镜脚本的完整性
   - 检查是否包含所有必需元素
   - 验证术语使用的正确性
   - 生成验证报告

2. **scripts/format_storyboard.py**
   - 格式化分镜脚本输出
   - 转换为不同格式（JSON、Markdown、Word）
   - 应用标准模板

### 参考文档

- **references/storyboard_standards.md**：镜头类型和术语标准
- **references/camera_movements.md**：相机运动详解
- **references/sound_design.md**：音效设计指南
- **references/examples.md**：实际使用示例

## Inputs Needed（所需输入）

### 必需输入
- 剧本文本或创意概念描述
- 目标媒体类型（电影、广告、MV等）

### 可选输入
- 目标时长
- 风格参考或美学方向
- 已知的技术限制（预算、设备、场景限制）
- 特定要求（如：必须包含某些镜头类型）

## Outputs（输出）

### 标准输出格式

SCENE [编号]: [INT/EXT] [地点] - [时间]

场景描述
[环境和气氛的描述，50-150字]

─────────────────────────────

SHOT [编号]: [镜头类型]
镜头：[具体镜头术语]
相机运动：[运动类型，如无则标注Static]
场景描述：[详细的画面描述]
演员/道具：[相关参与者]
对白：[对话，如有]
音效：[音效标注]
音乐：[音乐提示]
动作描述：[演员和物体的具体动作]
技术说明：[灯光、特效等说明]

─────────────────────────────
[下一个镜头…]


### 输出格式选项

1. **Markdown格式**：可读性强，易于编辑
2. **JSON格式**：结构化数据，便于程序处理
3. **Word文档**：使用 `assets/templates/storyboard_template.docx`

## Quality Checklist（质量检查清单）

生成分镜脚本后，必须检查：

- [ ] 每个场景都有唯一的编号
- [ ] 每个镜头都有唯一的编号
- [ ] 所有镜头都使用了标准术语
- [ ] 场景描述清晰可执行
- [ ] 所有演员和道具都被明确提及
- [ ] 音效和音乐提示完整
- [ ] 镜头类型符合行业标准术语
- [ ] 运镜逻辑流畅，符合剧情节奏
- [ ] 没有遗漏关键转折或动作
- [ ] 技术要求明确且可行
- [ ] 时间连贯性合理
- [ ] 视觉连贯性良好（遵循180度规则等）

## Examples（示例）

### 示例1：简单对话场景

**输入**：
"两个朋友在咖啡馆相遇，其中一个有重要新闻要分享。"

**输出**：

SCENE 001: INT COFFEE SHOP - AFTERNOON

场景描述
阳光透过大窗户洒进现代咖啡馆。午餐后的顾客零散分布。温暖、放松的氛围。

─────────────────────────────

SHOT 1: Wide Shot
镜头：Establishing Wide Shot
咖啡馆的全景。ALEX走进门，扫描人群，发现JAMIE坐在靠窗的桌子。
相机运动：Static
音效：咖啡馆环境音，轻松的背景音乐
技术说明：自然光为主，补充温暖的室内灯光

─────────────────────────────

SHOT 2: Medium Shot
镜头：Medium Shot - JAMIE
JAMIE看到ALEX，脸上出现微笑和轻微的紧张。拿起咖啡杯。
对白：Jamie - “嘿！你来了！”（语调：热情但略显拘谨）
相机运动：Static
音效：背景音乐继续

─────────────────────────────

SHOT 3: Close-up
镜头：Close-up - ALEX的脸
ALEX的表情显示出某种压抑的情绪。走向桌子时，轻微的呼吸加深。
相机运动：Slow Dolly In
音效：心跳声（subtle）

─────────────────────────────

SHOT 4: Medium Two-Shot
镜头：Medium Shot（两人在框中）
ALEX坐下。初始时轻松的对话。两人都在理自己的咖啡。
对白：

Alex - “最近怎么样？”
Jamie - “还不错。你看起来有点不同…”
相机运动：Static
音效：环境音，背景音乐音量降低

─────────────────────────────

SHOT 5: Extreme Close-up
镜头：Extreme Close-up - ALEX的眼睛
ALEX的眼睛。深吸一口气。决定打破沉默。
相机运动：Dolly In to Extreme Close-up
音效：心跳声（subtle）

─────────────────────────────

SHOT 6: Over-the-Shoulder Shot
镜头：Over-the-Shoulder Shot（从JAMIE的肩膀看ALEX）
从JAMIE的肩膀看ALEX。ALEX开始说话。
对白：Alex - “Jamie，我需要告诉你一件事。我…我要搬家了。”
相机运动：Static
音效：背景音乐音量降低

─────────────────────────────

SHOT 7: Reverse Over-the-Shoulder Shot
镜头：Over-the-Shoulder Shot（从ALEX的肩膀看JAMIE）
从ALEX的肩膀看JAMIE。JAMIE的表情从惊讶变为理解再到悲伤。
相机运动：Slight Focus Shift，强调眼睛
音乐：音乐变得更加温暖和哀伤


## Best Practices（最佳实践）

### DO（应该做）
- ✓ 使用专业的电影术语
- ✓ 保持描述简洁但富有信息量
- ✓ 考虑编辑的节奏和流程
- ✓ 使用标准的分镜脚本格式
- ✓ 包含足够的细节以供制作参考
- ✓ 考虑视觉连贯性（眼线匹配、轴线规则）
- ✓ 为每个镜头标注合理的时长

### DON'T（不应该做）
- ✗ 过度描述不相关的细节
- ✗ 使用模糊的镜头描述
- ✗ 忽略音效和音乐的重要性
- ✗ 创建不可执行的镜头
- ✗ 破坏视觉连贯性
- ✗ 使用非标准术语
- ✗ 遗漏关键的技术信息

## Troubleshooting（故障排除）

### 常见问题

**Q: 如何确定镜头数量？**
A: 根据目标时长和叙事节奏。一般每个镜头3-6秒，30秒广告需要5-8个镜头。

**Q: 如何处理场景转换？**
A: 使用转场标注：CUT TO（硬切换）、FADE TO（淡出淡入）、DISSOLVE（溶解）。

**Q: 演员指导应该有多详细？**
A: 描述情感状态和关键动作，不要过度指导表演细节。

**Q: 如何标注音效和音乐？**
A: 使用明确的术语，区分背景音乐、音效、环境音和对白。

## References（参考资源）

详细参考信息请查阅：
- `references/storyboard_standards.md`：镜头类型和术语标准
- `references/camera_movements.md`：相机运动详解
- `references/sound_design.md`：音效设计指南
- `references/examples.md`：更多实际使用示例

3.3 第四步：准备打包资源

根据官方最佳实践，打包资源包括scripts/、references/和assets/三类。每类资源有不同的职责和使用方式。

3.3.1 脚本（Scripts）的准备

何时需要脚本：

相同代码屡次重写
需要高度可控的执行结果
任务具有确定的逻辑流程

脚本编写最佳实践：

参数化设计：所有配置都应该通过参数传入
错误处理：包含完整的异常处理和用户友好的错误信息
日志清晰：使用logging模块，便于调试
文档注释：每个函数都有清晰的docstring

3.4 第五步：创建脚本文件

3.3.1 验证脚本

创建 scripts/validate_storyboard.py：

#!/usr/bin/env python3
"""
分镜脚本验证工具
验证生成的分镜脚本是否包含所有必需元素
"""

import json
import re
import sys
from typing import Dict, List, Tuple, Optional

class StoryboardValidator:
    """分镜脚本验证器"""
    
    # 标准镜头类型
    STANDARD_SHOT_TYPES = [
        "Wide Shot", "Medium Shot", "Close-up", "Extreme Close-up",
        "High Angle", "Low Angle", "POV", "Over-the-Shoulder Shot",
        "Two-Shot", "Establishing Shot", "OTS", "WS", "MS", "CU", "ECU"
    ]
    
    # 标准相机运动
    STANDARD_CAMERA_MOVEMENTS = [
        "Dolly In", "Dolly Out", "Pan", "Tilt", "Tracking",
        "Crane", "Zoom", "Static", "Focus Shift"
    ]
    
    # 必需元素关键词
    REQUIRED_ELEMENTS = {
        "scene_description": ["场景描述", "Scene Description"],
        "shot_type": ["镜头", "Shot", "Shot Type"],
        "action": ["动作", "Action", "动作描述"],
        "camera": ["相机", "Camera", "摄像机"]
    }
    
    def __init__(self, storyboard_text: str):
        """
        初始化验证器
        
        Args:
            storyboard_text: 分镜脚本文本
        """
        self.storyboard_text = storyboard_text
        self.scenes = self._extract_scenes()
        self.validation_results = {}
    
    def _extract_scenes(self) -> List[Dict]:
        """从文本中提取场景"""
        scenes = []
        # 匹配 SCENE XXX: 模式
        scene_pattern = r'SCENE\s+(\d+):\s*(.*?)(?=SCENE\s+\d+:|$)'
        matches = re.finditer(scene_pattern, self.storyboard_text, re.DOTALL | re.IGNORECASE)
        
        for match in matches:
            scene_num = match.group(1)
            scene_header = match.group(2).split('\n')[0] if match.group(2) else ""
            scene_content = match.group(2)
            
            scenes.append({
                'number': scene_num,
                'header': scene_header.strip(),
                'content': scene_content,
                'shots': self._extract_shots(scene_content)
            })
        
        return scenes
    
    def _extract_shots(self, scene_content: str) -> List[Dict]:
        """从场景中提取镜头"""
        shots = []
        # 匹配 SHOT XXX: 模式
        shot_pattern = r'SHOT\s+(\d+):\s*(.*?)(?=SHOT\s+\d+:|$)'
        matches = re.finditer(shot_pattern, scene_content, re.DOTALL | re.IGNORECASE)
        
        for match in matches:
            shot_num = match.group(1)
            shot_content = match.group(2)
            shots.append({
                'number': shot_num,
                'content': shot_content
            })
        
        return shots
    
    def validate_structure(self) -> Dict:
        """验证分镜脚本的基本结构"""
        results = {
            'valid': True,
            'errors': [],
            'warnings': [],
            'statistics': {}
        }
        
        # 检查场景数量
        if not self.scenes:
            results['valid'] = False
            results['errors'].append("未找到任何场景（SCENE）")
            return results
        
        results['statistics']['total_scenes'] = len(self.scenes)
        results['statistics']['total_shots'] = sum(
            len(scene['shots']) for scene in self.scenes
        )
        
        # 验证每个场景
        for scene in self.scenes:
            scene_num = scene['number']
            
            # 检查场景标题格式
            if not scene['header']:
                results['warnings'].append(
                    f"场景 {scene_num} 缺少场景标题"
                )
            
            # 检查是否有镜头
            if not scene['shots']:
                results['warnings'].append(
                    f"场景 {scene_num} 没有镜头定义"
                )
            
            # 验证每个镜头
            for shot in scene['shots']:
                self._validate_shot(shot, scene_num, results)
        
        return results
    
    def _validate_shot(self, shot: Dict, scene_num: str, results: Dict):
        """验证单个镜头"""
        shot_num = shot['number']
        content = shot['content'].upper()
        shot_key = f"Scene {scene_num}, Shot {shot_num}"
        
        # 检查必需元素
        has_scene_desc = any(
            keyword in content for keyword in 
            self.REQUIRED_ELEMENTS['scene_description']
        )
        if not has_scene_desc and len(self.scenes) == 1:
            # 如果只有一个场景，场景描述可能在场景级别
            pass
        else:
            results['warnings'].append(
                f"{shot_key}: 建议包含场景描述"
            )
        
        # 检查镜头类型
        has_shot_type = any(
            shot_type.upper() in content 
            for shot_type in self.STANDARD_SHOT_TYPES
        )
        if not has_shot_type:
            results['warnings'].append(
                f"{shot_key}: 未使用标准镜头术语"
            )
        
        # 检查相机运动
        has_camera_movement = any(
            movement.upper() in content
            for movement in self.STANDARD_CAMERA_MOVEMENTS
        )
        if not has_camera_movement:
            results['warnings'].append(
                f"{shot_key}: 建议标注相机运动（如无运动则标注Static）"
            )
    
    def validate_terminology(self) -> Dict:
        """验证术语使用的正确性"""
        results = {
            'valid_shot_types': [],
            'camera_movements': [],
            'non_standard_terms': []
        }
        
        text_upper = self.storyboard_text.upper()
        
        # 识别使用的镜头类型
        for shot_type in self.STANDARD_SHOT_TYPES:
            if shot_type.upper() in text_upper:
                results['valid_shot_types'].append(shot_type)
        
        # 识别摄像机运动
        for movement in self.STANDARD_CAMERA_MOVEMENTS:
            if movement.upper() in text_upper:
                results['camera_movements'].append(movement)
        
        return results
    
    def validate_completeness(self) -> Dict:
        """验证完整性"""
        results = {
            'has_dialogue': False,
            'has_sound': False,
            'has_music': False,
            'has_technical_notes': False
        }
        
        text_upper = self.storyboard_text.upper()
        
        # 检查对白
        if any(keyword in text_upper for keyword in ['对白', 'DIALOGUE', 'DIALOG']):
            results['has_dialogue'] = True
        
        # 检查音效
        if any(keyword in text_upper for keyword in ['音效', 'SOUND', 'SOUND EFFECT']):
            results['has_sound'] = True
        
        # 检查音乐
        if any(keyword in text_upper for keyword in ['音乐', 'MUSIC', 'SCORE']):
            results['has_music'] = True
        
        # 检查技术说明
        if any(keyword in text_upper for keyword in ['技术', 'TECHNICAL', '灯光', 'LIGHTING']):
            results['has_technical_notes'] = True
        
        return results
    
    def generate_report(self) -> str:
        """生成完整的验证报告"""
        structure_validation = self.validate_structure()
        terminology_validation = self.validate_terminology()
        completeness_validation = self.validate_completeness()
        
        report = []
        report.append("=" * 70)
        report.append("分镜脚本验证报告")
        report.append("=" * 70)
        
        # 结构验证
        report.append("\n【结构验证】")
        report.append(f"总场景数: {structure_validation['statistics'].get('total_scenes', 0)}")
        report.append(f"总镜头数: {structure_validation['statistics'].get('total_shots', 0)}")
        
        if structure_validation['errors']:
            report.append("\n❌ 错误:")
            for error in structure_validation['errors']:
                report.append(f"  - {error}")
        
        if structure_validation['warnings']:
            report.append("\n⚠️  警告:")
            for warning in structure_validation['warnings']:
                report.append(f"  - {warning}")
        
        # 术语验证
        report.append("\n【术语验证】")
        report.append(f"使用的镜头类型: {', '.join(terminology_validation['valid_shot_types'][:5]) or '未指定'}")
        if len(terminology_validation['valid_shot_types']) > 5:
            report.append(f"  ... 共 {len(terminology_validation['valid_shot_types'])} 种")
        report.append(f"摄像机运动: {', '.join(terminology_validation['camera_movements']) or '无'}")
        
        # 完整性验证
        report.append("\n【完整性验证】")
        report.append(f"包含对白: {'✓' if completeness_validation['has_dialogue'] else '✗'}")
        report.append(f"包含音效: {'✓' if completeness_validation['has_sound'] else '✗'}")
        report.append(f"包含音乐: {'✓' if completeness_validation['has_music'] else '✗'}")
        report.append(f"包含技术说明: {'✓' if completeness_validation['has_technical_notes'] else '✗'}")
        
        # 总体评分
        report.append("\n【总体评估】")
        total_issues = len(structure_validation['errors']) + len(structure_validation['warnings'])
        if total_issues == 0:
            report.append("✓ 分镜脚本质量优秀，所有检查项通过")
        elif total_issues <= 3:
            report.append("⚠️  分镜脚本质量良好，有少量建议")
        else:
            report.append("✗ 分镜脚本需要改进，请参考上述警告")
        
        report.append("=" * 70)
        
        return "\n".join(report)


def main():
    """主函数"""
    if len(sys.argv) > 1:
        # 从文件读取
        with open(sys.argv[1], 'r', encoding='utf-8') as f:
            storyboard_text = f.read()
    else:
        # 从标准输入读取
        storyboard_text = sys.stdin.read()
    
    validator = StoryboardValidator(storyboard_text)
    report = validator.generate_report()
    print(report)


if __name__ == "__main__":
    main()

3.3.2 格式化脚本

创建 scripts/format_storyboard.py：

#!/usr/bin/env python3
"""
分镜脚本格式化工具
将分镜脚本转换为不同格式（JSON、Markdown、结构化文本）
"""

import json
import re
import sys
from typing import Dict, List
from datetime import datetime

class StoryboardFormatter:
    """分镜脚本格式化器"""
    
    def __init__(self, storyboard_text: str):
        self.storyboard_text = storyboard_text
        self.scenes = self._parse_storyboard()
    
    def _parse_storyboard(self) -> List[Dict]:
        """解析分镜脚本文本"""
        scenes = []
        scene_pattern = r'SCENE\s+(\d+):\s*(.*?)(?=SCENE\s+\d+:|$)'
        matches = re.finditer(scene_pattern, self.storyboard_text, re.DOTALL | re.IGNORECASE)
        
        for match in matches:
            scene_num = match.group(1)
            scene_content = match.group(2)
            
            # 提取场景描述
            scene_desc_match = re.search(r'场景描述\s*\n(.*?)(?=SHOT|$)', scene_content, re.DOTALL | re.IGNORECASE)
            scene_description = scene_desc_match.group(1).strip() if scene_desc_match else ""
            
            # 提取镜头
            shots = self._extract_shots(scene_content)
            
            scenes.append({
                'number': scene_num,
                'description': scene_description,
                'shots': shots
            })
        
        return scenes
    
    def _extract_shots(self, scene_content: str) -> List[Dict]:
        """提取镜头信息"""
        shots = []
        shot_pattern = r'SHOT\s+(\d+):\s*(.*?)(?=SHOT\s+\d+:|$)'
        matches = re.finditer(shot_pattern, scene_content, re.DOTALL | re.IGNORECASE)
        
        for match in matches:
            shot_num = match.group(1)
            shot_content = match.group(2)
            
            # 解析镜头内容
            shot_info = {
                'number': shot_num,
                'shot_type': self._extract_field(shot_content, ['镜头', 'Shot Type']),
                'camera_movement': self._extract_field(shot_content, ['相机运动', 'Camera Movement']),
                'description': self._extract_field(shot_content, ['场景描述', 'Description']),
                'actors': self._extract_field(shot_content, ['演员', 'Actors']),
                'dialogue': self._extract_field(shot_content, ['对白', 'Dialogue']),
                'sound': self._extract_field(shot_content, ['音效', 'Sound']),
                'music': self._extract_field(shot_content, ['音乐', 'Music']),
                'action': self._extract_field(shot_content, ['动作', 'Action']),
                'technical_notes': self._extract_field(shot_content, ['技术', 'Technical'])
            }
            
            shots.append(shot_info)
        
        return shots
    
    def _extract_field(self, text: str, keywords: List[str]) -> str:
        """从文本中提取字段"""
        for keyword in keywords:
            pattern = rf'{keyword}[：:]\s*(.*?)(?=\n[A-Z]|$)'
            match = re.search(pattern, text, re.DOTALL | re.IGNORECASE)
            if match:
                return match.group(1).strip()
        return ""
    
    def to_json(self) -> str:
        """转换为JSON格式"""
        output = {
            'metadata': {
                'created_at': datetime.now().isoformat(),
                'total_scenes': len(self.scenes),
                'total_shots': sum(len(scene['shots']) for scene in self.scenes)
            },
            'scenes': self.scenes
        }
        return json.dumps(output, ensure_ascii=False, indent=2)
    
    def to_markdown(self) -> str:
        """转换为Markdown格式"""
        lines = []
        lines.append("# 分镜脚本")
        lines.append(f"\n**生成时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        lines.append(f"**总场景数**: {len(self.scenes)}")
        lines.append(f"**总镜头数**: {sum(len(scene['shots']) for scene in self.scenes)}")
        lines.append("\n---\n")
        
        for scene in self.scenes:
            lines.append(f"\n## 场景 {scene['number']}")
            if scene['description']:
                lines.append(f"\n**场景描述**: {scene['description']}\n")
            
            for shot in scene['shots']:
                lines.append(f"\n### 镜头 {shot['number']}")
                if shot['shot_type']:
                    lines.append(f"- **镜头类型**: {shot['shot_type']}")
                if shot['camera_movement']:
                    lines.append(f"- **相机运动**: {shot['camera_movement']}")
                if shot['description']:
                    lines.append(f"- **描述**: {shot['description']}")
                if shot['dialogue']:
                    lines.append(f"- **对白**: {shot['dialogue']}")
                if shot['sound']:
                    lines.append(f"- **音效**: {shot['sound']}")
                if shot['music']:
                    lines.append(f"- **音乐**: {shot['music']}")
                lines.append("")
        
        return "\n".join(lines)


def main():
    """主函数"""
    if len(sys.argv) < 2:
        print("用法: format_storyboard.py <format> [input_file]")
        print("格式: json, markdown")
        sys.exit(1)
    
    output_format = sys.argv[1]
    
    if len(sys.argv) > 2:
        with open(sys.argv[2], 'r', encoding='utf-8') as f:
            storyboard_text = f.read()
    else:
        storyboard_text = sys.stdin.read()
    
    formatter = StoryboardFormatter(storyboard_text)
    
    if output_format == 'json':
        print(formatter.to_json())
    elif output_format == 'markdown':
        print(formatter.to_markdown())
    else:
        print(f"不支持的格式: {output_format}")
        sys.exit(1)


if __name__ == "__main__":
    main()

3.5 第六步：创建参考文档

3.4.1 标准参考文档

创建 references/storyboard_standards.md：

# 分镜脚本标准参考指南

## 目录
1. [镜头类型完整列表](#镜头类型完整列表)
2. [相机运动详解](#相机运动详解)
3. [场景编码标准](#场景编码标准)
4. [音效设计规范](#音效设计规范)
5. [行业标准格式](#行业标准格式)

## 镜头类型完整列表

### 按景别分类

#### 1. 超广角镜头 (EWS - Extreme Wide Shot)
- **定义**：显示整个场景环境，人物很小或不可见
- **用途**：建立场景、展示地理位置、显示环境规模
- **视角**：从很远的距离拍摄
- **示例**："俯拍，显示整个城市天际线，晨光刚刚照亮高楼"

#### 2. 广角镜头 (WS - Wide Shot)
- **定义**：显示人物全身和周围环境
- **用途**：展示人物与环境的关系、建立空间感
- **视角**：距离人物约10-15英尺
- **示例**："主角站在空荡荡的办公室，阳光从大窗户透入"

#### 3. 中景镜头 (MS - Medium Shot)
- **定义**：从腰部或胸部开始拍摄人物
- **用途**：对话场景、日常动作、人物互动
- **视角**：距离人物约6-8英尺
- **示例**："两个角色站在办公桌前对话，可以看到他们的上半身和手势"

#### 4. 特写镜头 (CU - Close-up)
- **定义**：填满人物面部或重要道具
- **用途**：强调情感、显示细节、突出重要性
- **视角**：距离人物2-3英尺
- **示例**："极度近距离拍摄主角的眼睛，泪水滑落"

#### 5. 极特写镜头 (ECU - Extreme Close-up)
- **定义**：只显示眼睛、嘴唇、手指等细小部分
- **用途**：突出细节、强调关键道具、创造紧张感
- **视角**：非常近距离，可能只显示眼睛或嘴
- **示例**："特写拍摄年份标签，年份从2023变为2024"

#### 6. 多人镜头
- **Two-Shot**：两个人在同一镜头中
- **Three-Shot**：三个人在同一镜头中
- **Group Shot**：多人群组镜头

### 按机位分类

#### 俯视镜头 (High Angle)
- **效果**：显示权力差异，人物显得渺小、脆弱
- **用途**：显示角色的弱势地位、被压迫感
- **示例**："俯视拍摄，主角坐在巨大的办公室中央"

#### 仰视镜头 (Low Angle)
- **效果**：凸显人物的权力、威严
- **用途**：显示角色的强势、英雄感
- **示例**："仰视拍摄，反派角色俯视镜头向下看"

#### 平视镜头 (Eye Level)
- **效果**：中立、客观
- **用途**：标准视角，大多数场景使用
- **示例**："正面平视拍摄，两角色对话"

#### 荷兰角 (Dutch Angle)
- **效果**：制造紧张、不安
- **用途**：显示不稳定的心理状态、混乱场景
- **示例**："45度倾斜的机位，显示不稳定的心理状态"

#### 主观镜头 (POV - Point of View)
- **效果**：从角色视角看世界
- **用途**：让观众体验角色的视角
- **示例**："从主角的视角看门把手，手伸向门"

## 相机运动详解

### 1. 摇镜头 (Pan)
- **定义**：相机左右转动，固定垂直轴
- **用途**：跟随人物从一侧移到另一侧；探索宽阔的场景
- **执行**：起点 → 终点，标注速度（快速、中速、缓慢）
- **示例**："缓慢摇镜头，从街道左侧的咖啡厅摇至右侧的公园"

### 2. 俯仰 (Tilt)
- **定义**：相机上下转动，固定水平轴
- **用途**：显示人物从坐到站；显示高大的建筑
- **执行**：从下向上或从上向下
- **示例**："缓慢向上俯仰，从地面遍布的碎片俯仰至站起来的主角"

### 3. 推镜头 (Dolly In)
- **定义**：相机向前移动，画面变大
- **用途**：增强紧张感；突出重要对象
- **执行**：描述起始距离和最终距离
- **示例**："快速推镜头，从远处推进到主角脸部特写，强调她的决定"

### 4. 拉镜头 (Dolly Out)
- **定义**：相机向后移动，画面变小
- **用途**：揭示更多环境；显示孤独感
- **执行**：描述运动速度和终止位置
- **示例**："缓慢拉镜头，从主角脸部特写拉出，显示她坐在空荡荡的房间"

### 5. 跟镜头 (Follow Cam / Tracking Shot)
- **定义**：相机跟随运动的对象
- **用途**：保持观众的焦点；增加动感
- **执行**：描述跟随对象的运动路径
- **示例**："平稳跟镜头，跟随主角从客厅走进卧室，进行对话"

### 6. 升降 (Crane / Lift)
- **定义**：相机升高或降低（通常需要特殊设备）
- **用途**：戏剧化地改变视角；显示垂直空间
- **执行**：描述升降的幅度和速度
- **示例**："优雅的升降镜头，从地面升至天花板，显示豪华的办公室"

### 7. 变焦 (Zoom)
- **定义**：改变相机焦距而不改变相机位置
- **用途**：强调主体；突然改变情绪
- **执行**：标注变焦的速度和范围
- **示例**："快速变焦放大，从广角拉至特写，突出惊讶的表情"

## 场景编码标准

### 格式

[INT/EXT] [位置] - [时间]


### 位置示例
- INT COFFEE SHOP（内景，咖啡厅）
- EXT CITY STREET - DAY（外景，城市街道，日间）
- INT OFFICE BUILDING - HALLWAY（内景，办公楼走廊）

### 时间标注
- DAY（日间，通常指日出到日落）
- NIGHT（夜间）
- DAWN（日出）
- DUSK（黄昏）
- GOLDEN HOUR（黄金时段，日出日落前后）
- BLUE HOUR（蓝色时段，日落后、完全黑夜前）

## 音效设计规范

### 声音层级

1. **对白 (Dialogue)**
   - 主要故事信息
   - 角色交互
   - 清晰、可理解

2. **音效 (Sound Effects)**
   - 环境声音
   - 动作声音
   - 物体互动声音

3. **背景音乐 (Score/Music)**
   - 情感背景
   - 节奏指导
   - 氛围设定

### 声音技术

#### 环境音 (Ambient Sound)
- 自然场景声音
- 持续背景
- 建立环境可信度

#### 音效效果 (Sound Effects)
- 具体的声音事件
- 与动作同步
- 增强视觉可信度

#### 音乐指导
- **流派**：古典、爵士、摇滚等
- **节奏**：快速（活泼）、缓慢（沉思）
- **强度**：低音量（背景）、中等、高音量（突出）
- **音调**：高（紧张）、低（沉重）

## 行业标准格式

### 标准分镜脚本格式

场景编号: [INT/EXT] 地点 - 时间
─────────────────────────────

镜头号: [场景号] + [镜头序列]
镜头类型: [广角/中景等]
相机运动: [if applicable]
布景: [场景描述]
演员/道具: [相关参与者]
对白/音效: [对话或声音标注]
动作描述: [演员和物体的具体动作]
技术说明: [灯光、特效等说明]

───────────────────────────


### 转场效果

- **CUT TO**: 硬切换
- **FADE TO**: 淡出后淡入
- **DISSOLVE**: 溶解过渡
- **WIPE**: 推屏过渡
- **MATCH CUT**: 匹配剪辑

## 常见错误和如何避免

### 错误 1：不清晰的镜头描述
❌ "拍摄两个人谈话"
✓ "Medium Shot Over-the-Shoulder从ALEX看JORDAN，当JORDAN解释情况"

### 错误 2：忽视音效设计
❌ 没有任何声音指导
✓ 包括背景音乐、环境音和特定的音效

### 错误 3：不一致的视觉流
❌ 镜头无逻辑跳跃
✓ 使用眼线匹配和轴线规则保持连贯性

### 错误 4：过度描述
❌ "演员走进房间，看起来有点累，穿着蓝色衬衫，天气是晴天..."
✓ "ALEX走进房间，疲惫地。"

### 错误 5：忽略演员行为
❌ 只关注对白和镜头
✓ 包括表情、手势、身体语言

3.4.2 相机运动详解

创建 references/camera_movements.md：

# 相机运动完整指南

## 概述
相机运动是电影语言的重要组成部分，它引导观众的注意力，创造情绪，并推动叙事。

## 基础运动类型

### 静态镜头 (Static)
- **定义**：相机完全静止
- **用途**：让动作在画面中发生，不干扰观众
- **适用场景**：对话、静态场景、强调画面内容

### 推进 (Dolly In)
- **技术**：相机向主体移动
- **效果**：增强紧张感、强调重要性
- **速度**：缓慢（3-5秒）或快速（1-2秒）
- **示例**："缓慢推进到主角的脸，强调她的决定"

### 拉出 (Dolly Out)
- **技术**：相机远离主体
- **效果**：揭示环境、显示孤独、结束场景
- **速度**：通常缓慢
- **示例**："从特写拉出，显示主角独自在空房间"

### 摇镜头 (Pan)
- **技术**：相机左右旋转
- **效果**：跟随动作、探索空间
- **速度**：根据动作速度调整
- **示例**："快速摇镜头，跟随奔跑的角色"

### 俯仰 (Tilt)
- **技术**：相机上下旋转
- **效果**：显示高度、跟随垂直动作
- **速度**：通常缓慢
- **示例**："向上俯仰，从地面到摩天大楼顶部"

## 高级运动类型

### 跟拍 (Tracking Shot)
- **技术**：相机跟随对象移动
- **效果**：保持焦点、增加动感
- **设备**：可能需要轨道或稳定器
- **示例**："跟拍主角穿过拥挤的市场"

### 升降 (Crane Shot)
- **技术**：相机垂直升降
- **效果**：戏剧化视角变化
- **设备**：需要升降设备
- **示例**："从地面升至屋顶，显示全景"

### 变焦 (Zoom)
- **技术**：改变焦距，不移动相机
- **效果**：快速强调、情绪变化
- **注意**：与推拉镜头效果不同
- **示例**："快速变焦到眼睛，强调惊讶"

## 组合运动

### 推拉摇 (Dolly Pan)
- 同时推进和摇镜头
- 创造复杂的空间感

### 升降摇 (Crane Pan)
- 升降同时摇镜头
- 展示大范围环境

## 运动速度

### 缓慢运动
- 创造沉思、优雅的感觉
- 适合情感场景

### 快速运动
- 创造紧张、动感
- 适合动作场景

### 变速运动
- 从慢到快：建立紧张
- 从快到慢：强调重点

## 运动与情绪

| 运动类型 | 情绪效果 |
|---------|---------|
| 缓慢推进 | 紧张、专注 |
| 快速拉出 | 孤独、失落 |
| 摇镜头 | 探索、跟随 |
| 升降 | 戏剧化、揭示 |
| 跟拍 | 动感、参与感 |

## 技术考虑

### 设备需求
- **手持**：自然、不稳定
- **三脚架**：稳定、精确
- **稳定器**：平滑运动
- **轨道**：精确的推拉
- **升降机**：垂直运动

### 预算影响
- 静态镜头：最低成本
- 手持运动：低成本
- 轨道运动：中等成本
- 升降运动：高成本

## 最佳实践

1. **有目的的运动**：每个运动都应该有叙事目的
2. **速度匹配**：运动速度应该匹配场景情绪
3. **设备选择**：根据预算和效果选择设备
4. **测试运动**：在实际拍摄前测试运动路径
5. **备用方案**：准备静态备用镜头

3.6 第七步：创建示例文件

创建 references/examples.md：

# 分镜脚本生成器 - 实际使用示例

## 示例 1: 简短的信息交换场景

### 输入请求
"生成一个两分钟的分镜脚本。场景：两个陌生人在火车上相遇。他们开始对话。气氛从尴尬变为友好。"

### 生成的分镜脚本

**SCENE 001: INT TRAIN CAR - EVENING**

**场景描述**
一列现代的城市火车。车厢半满，乘客散布其间。黄色灯光。轻微的噪音和摇晃。傍晚的光线从窗户透入。

**SHOT 1: Wide Shot - Establishing**
镜头：Wide Establishing Shot
火车车厢的视图。A和B各自坐在对面的座位上，之间有一排空座位。
相机运动：Static
音效：火车轨道的声音，远处的交通噪音
技术说明：自然光混合车厢灯光

**SHOT 2: Close-up - A**
镜头：Close-up
A看出窗外，表情放松但略显无聊。手拿着手机。
相机运动：Slow Dolly In
音效：环境音继续

**SHOT 3: Close-up - B**
镜头：Close-up
B看着A（not obvious），有点犹豫。想要说什么但不确定。
相机运动：Static
音效：环境音

**SHOT 4: Medium Two-Shot**
镜头：Medium Two-Shot
两人在框中，之间有空座位。沉默时刻。
相机运动：Static
音效：火车声音，沉默的紧张

**SHOT 5: Close-up - B决定**
镜头：Close-up
B吸气，似乎下了决心。转向A。
相机运动：Focus Shift from window to B's face
音效：心跳声（subtle）

**SHOT 6: Close-up - A注意到**
镜头：Close-up
A感觉被注视，抬起头，转向B。
对白：A - "嗨？" （语调：疑惑但友好）
相机运动：Static
音效：环境音

**SHOT 7: Over-the-Shoulder - B的视角**
镜头：Over-the-Shoulder Shot
从B的肩膀看A，A看向B。
对白：B - "我注意到你在读什么书..." （指向A的包）
相机运动：Slight Dolly In
音效：环境音

**SHOT 8: Close-up - A的反应**
镜头：Close-up
A的脸绽放出微笑。释放，愉快。
对白：A - "噢！这是...我真的很喜欢这个作者。"
相机运动：Static
音效：轻松的背景音乐开始

**SHOT 9: Focus Shift**
镜头：Two-Shot Medium
两人都在框中。A用手比划，开始热情地谈论这本书。
相机运动：Focus Shift from A to B
音效：火车声音变得更软

**SHOT 10: 对话蒙太奇**
一系列快速的反向过肩镜头
- B说话（Close-up）
- A回应（Close-up）
- B笑（特写）
- A也笑（特写）
相机运动：Cut between shots
对白：
- B - "我也正在读那个系列!"
- A - "真的吗？你在哪一本？"
音效：轻松的背景音乐出现

**SHOT 11: Wide Shot - 现在的朋友**
镜头：Medium Two-Shot
火车在运动中。两人现在坐得更近，持续对话。表情都很愉快。
相机运动：Slow Dolly Out
音效：火车的声音，背景音乐继续
技术说明：温暖的光线，友好的氛围

---

## 示例 2: 戏剧性的启示场景

### 输入请求
"生成一个包含重要启示的分镜脚本。两个角色意识到他们有共同的过去。气氛从平静变为惊讶再到理解。"

### 生成的分镜脚本

**SCENE 023: EXT PARK - AFTERNOON**

**场景描述**
一个安静的公园。树木环绕。长椅排列在路旁。下午的温暖光线。几个人散布其间，但主要是空荡荡的。平静的气氛。

**SHOT 1: Wide Shot**
镜头：Wide Shot
公园的宽阔视图。C和D在不同的长椅上。D靠近C。
相机运动：Static
音效：鸟鸣，树叶沙沙声，远处的城市声音

**SHOT 2: Close-up - C思考**
镜头：Close-up
C坐着，思考。看似在处理某些想法。
相机运动：Slow Dolly In
音效：环境音

**SHOT 3: Medium Shot - D接近**
镜头：Medium Shot
D站起来，缓慢地走向C。
相机运动：Tracking Shot following D
音效：脚步声，环境音

**SHOT 4: Medium Two-Shot - D坐下**
镜头：Medium Two-Shot
D坐在C的旁边。友好但有些距离。短暂的沉默。
对白：D - "你看起来不开心"
相机运动：Static
音效：环境音

**SHOT 5: Close-up - C的反应**
镜头：Close-up
C转向D，研究D的脸。突然，识别出什么。表情变化。
相机运动：Static
音效：环境音停止

**SHOT 6: Extreme Close-up - C的眼睛**
镜头：Extreme Close-up
C的眼睛扩大。焦点变化。记忆闪过。
相机运动：Quick Dolly In to Extreme Close-up
音效：心跳声（subtle，层底）

**SHOT 7: Close-up - C说出**
镜头：Close-up
C - "等等...你的名字不是...不是D吗？"
语调：惊讶，不确定但渐渐确定
相机运动：Static
音效：心跳声继续

**SHOT 8: Close-up - D的反应**
镜头：Close-up
D的脸从困惑变为相同的识别。冲击。
相机运动：Static
音效：心跳声增强

**SHOT 9: Focus Shift Montage**
镜头：Extreme Close-ups
- C的眼睛（回想）
- D的嘴（说名字）
- C的手（颤抖）
- D的脸（记忆）
相机运动：Focus Shift between shots, Slow Dolly In
音效：心跳声，细微的不和谐音乐

**SHOT 10: Medium Two-Shot**
镜头：Two-shot Medium
两人都转向彼此。距离中等。紧张的沉默。深刻的理解正在建立。
相机运动：Slow Dolly In, Focus on space between them
音效：环境音停止，只有微妙的音乐

**SHOT 11: Over-the-Shoulder Shot**
镜头：Over-the-Shoulder Shot
从D看C。
对白：C - "高中。学校乐队。你拉小提琴。"
语调：缓慢，确定
相机运动：Static
音效：音乐音量降低

**SHOT 12: Reverse Over-the-Shoulder**
镜头：Reverse Over-the-Shoulder Shot
从C看D。
对白：D - "是的...天哪，我怎么没认出你？"
语调：惊讶，一点点羞愧
相机运动：Static
音效：音乐继续

**SHOT 13: Close-up Montage - 情感**
- C的脸上一个小微笑（Close-up）
- D的脸上的眼泪开始滑落（Close-up）
- 他们的手彼此靠近（Extreme Close-up）
相机运动：Slow Dolly In
音效：背景音乐变得温暖和感人

**SHOT 14: Wide Shot - 再次连接**
镜头：Wide Shot
两人现在坐得很近，相互拥抱。公园环绕。光线变为金色。
相机运动：Slow Dolly Out and slight High Angle
音效：背景音乐达到高潮，鸟鸣，树叶声
技术说明：金色小时光线，温暖色调

---

## 示例 3: 快节奏的动作序列

### 输入请求
"创建一个40秒的快节奏追逐序列分镜脚本。角色E在逃离。多个环境变化。"

### 生成的分镜脚本

**SCENE 045: EXT STREET - DAY**

**场景描述**
城市街道。繁忙的行人交通。商店橱窗。快节奏的环境。阳光明亮。紧张的气氛。

**SHOT 1: Extreme Wide Shot - 建立追逐**
镜头：Extreme Wide Shot (High Angle)
街道的俯视视图。E快速运行。多个人物追逐。动作混乱但目标清晰。
相机运动：Static High Angle
音效：街道环境音，脚步声，呼喊声

**SHOT 2: Medium Shot - E跟拍**
镜头：Tracking Medium Shot
跟拍E奔跑。躲避行人。焦点在E。
相机运动：Fast Tracking Shot
音效：脚步声，喘气，环境音消失
技术说明：手持相机，增加动感

**SHOT 3: Wide Shot - 转角**
镜头：Wide Shot
E急速转过街角。追逐者继续。急促感。
相机运动：Quick Pan following E
音效：脚步声，碰撞声

**SHOT 4: Close-up - E的脸**
镜头：Close-up
E的脸显示确定和恐惧。汗水。集中。
相机运动：Quick Dolly In
音效：心跳声，喘气

**SHOT 5: Low Angle Tracking - 通过人群**
镜头：Low Angle Tracking Shot
E通过市场。扒摊。混乱。相机几乎与E的眼睛高度。
相机运动：Super Fast Tracking
音效：碰撞，呼救，混乱

**SHOT 6: Wide Shot - 反应**
镜头：Wide Shot
惊讶的人群看着E跑过。追逐者跟进。混乱。
相机运动：Static
音效：呼喊，混乱

**SHOT 7: Tight Medium Shot - 巷道**
镜头：Tight Medium Shot
E进入小巷。更暗。狭窄的空间。感觉被困。
相机运动：Fast Dolly In, slight shake
音效：脚步声回响，紧张音乐

**SHOT 8: Close-up - E决定**
镜头：Close-up
E看到逃生路线。决定转向。
相机运动：Quick Dolly In
音效：心跳声增强

**SHOT 9: Low Angle Wide - 爬升**
镜头：Low Angle Wide Shot
E拼命爬上救火梯。追逐者到达底部。
相机运动：Upward Tilt, tracking upward
音效：金属声，脚步声，呼喊

**SHOT 10: Wide Shot - E在屋顶**
镜头：Wide Shot
E在屋顶。喘气。转身看追逐者。边缘接近。
相机运动：Dolly In, slight High Angle
音效：风声，心跳声

**SHOT 11: Wide Shot - 极限**
镜头：Wide Shot
E看到另一个屋顶。间隙。决定。跑和飞跃。
相机运动：Tracking Shot, Focus Shift to gap
音效：音乐达到高潮，心跳声

**SHOT 12: Wide Motion - 飞跃**
镜头：Wide Motion Shot
E在空中，反对地平线。时间似乎减慢。
相机运动：Slow Motion, tracking
音效：音乐暂停，只有风声

**SHOT 13: Wide Shot - 着陆**
镜头：Wide Shot
E着陆，翻滚，恢复。追逐者停在边缘，不敢跳。
相机运动：Quick Cut back to normal speed
音效：音乐下降，紧张缓解

**SHOT 14: Close-up - 胜利呼吸**
镜头：Close-up
E，汗湿，疲惫但活着。深呼吸。看向天空。
相机运动：Slow Dolly Out
音效：阳光照射的安静时刻，轻松的音乐开始
技术说明：自然光，温暖色调

---

## 使用提示

1. **调整细节**：这些示例可以根据特定需求自定义
2. **添加颜色和灯光**：您可以要求特定的灯光设置
3. **音效要求**：列出特定想要的音效
4. **演员指导**：包括表演风格和表情指导
5. **时间**：指定场景或镜头的持续时间

## 输出选项

您可以要求以下格式：
- **标准格式**：按照本文档所示
- **带时间**：每个镜头的持续时间
- **带成本估计**：复杂度和制作成本指示
- **带音效清单**：所有所需音效的单独清单
- **带灯光设置**：每个镜头的灯光要求

3.7 第八步：创建资产文件

创建 assets/templates/storyboard_template.md：

注意：assets/文件夹中的文件不会进入Claude的上下文，而是作为输出的一部分或参考文件使用。

# 分镜脚本模板

## 项目信息
- 项目名称：___________
- 导演：___________
- 日期：___________
- 总时长：___________

---

## SCENE [编号]: [INT/EXT] [地点] - [时间]

### 场景描述
[环境和气氛的描述，50-150字]

---

### SHOT [编号]: [镜头类型]

**镜头**：[具体镜头术语]
**相机运动**：[运动类型，如无则标注Static]
**场景描述**：[详细的画面描述]
**演员/道具**：[相关参与者]
**对白**：[对话，如有]
**音效**：[音效标注]
**音乐**：[音乐提示]
**动作描述**：[演员和物体的具体动作]
**技术说明**：[灯光、特效等说明]
**时长**：[秒数]

---

[重复上述格式添加更多镜头]

3.8 第九步：质量检查和打包部署

3.8.1 质量检查

在发布Skill前，必须进行以下检查：

元数据检查：
- name字段符合规范（小写、连字符、<64字符）
- description使用第三人称
- description明确触发条件
- description包含关键词
SKILL.md检查：
- 包含所有必需部分（Purpose、When to Use、Process等）
- 长度<5000词
- 指令清晰可执行
- 决策逻辑完整
资源检查：
- scripts/中的脚本参数化
- references/按主题拆分
- assets/文件分类清晰
功能测试：
- 在Claude中实际加载并测试
- 验证Skill正确触发
- 测试边界情况
- 验证所有输出格式

3.8.2 打包和部署

打包步骤：

确保文件夹名称与Skill名称匹配（如storyboard-generator/）
检查所有文件完整性
创建ZIP文件（保留文件夹结构）
验证ZIP文件可以正常解压

部署步骤：

在Claude界面中上传ZIP文件
等待Claude解析和验证
测试Skill是否出现在可用列表中
使用/storyboard-generator直接调用测试

版本管理：

使用语义化版本号（如v1.0.0）
创建CHANGELOG.md记录变更
使用Git管理版本历史

第四部分：Skills与其他工具的对比

4.1 Skills vs MCP（Model Context Protocol）

特性	MCP	Skills
复杂度	需要服务器、HTTP接口	只需Markdown文件
上下文加载	全量加载工具定义	渐进式披露（元数据→SKILL.md→资源）
适用场景	外部服务集成（数据库、API）	工作流程+领域知识
执行模型	同步直接调用	提示词扩展+上下文修改
并发性	通常安全	非并发安全
Token成本	工具定义常驻	按需加载，成本更低

选择建议：

需要连接外部服务（数据库、API）→ 使用MCP
需要封装工作流程和知识库 → 使用Skills
需要两者结合 → 可以在Skill中调用MCP工具

4.2 Skills vs 子代理（Subagents）

特性	子代理	Skills
复杂度	独立Agent，需要配置	Markdown文件
上下文	动态加载，独立上下文	共享主对话上下文
适用场景	复杂决策、多步骤推理	结构化工作流
执行方式	独立运行，可并行	在主对话中执行
成本	每个子代理独立计费	共享主对话Token

选择建议：

需要独立推理和决策 → 使用子代理
需要结构化工作流程 → 使用Skills
需要长期项目状态管理 → 使用Projects

4.3 Skills vs 传统工具（Read/Write/Bash）

特性	传统工具	Skills
执行模型	同步直接执行	提示词扩展
目的	执行特定操作（读文件、写文件）	指导复杂工作流
返回值	即时结果（文件内容、执行状态）	对话上下文修改
并发安全	通常安全	非并发安全
成本	按操作计费	Token消耗（需优化）

选择建议：

简单文件操作 → 使用传统工具
复杂工作流程 → 使用Skills
需要结合使用 → Skills可以调用传统工具

4.4 场景选型决策树

需要扩展Claude能力？
│
├─ 需要连接外部服务（数据库、API）？
│  └─ 是 → 使用MCP
│
├─ 需要独立推理和复杂决策？
│  └─ 是 → 使用子代理
│
├─ 需要长期项目状态管理？
│  └─ 是 → 使用Projects
│
└─ 需要封装工作流程和领域知识？
   └─ 是 → 使用Skills ✓

第五部分：高级特性和优化

4.1 元数据扩展

除了基本的name和description，还可以添加：

---
name: storyboard-generator
description: ...
dependencies: python>=3.8
version: 1.0.0
author: Claude AI
tags: ["video-production", "filmmaking", "visual-design"]
compatibility: ["Claude Pro", "Claude Max"]
license: MIT
---

4.2 条件性调用

在SKILL.md中可以添加条件逻辑：

## When NOT to Use

不要使用此Skill当：
- 用户只需要简单的故事大纲
- 不需要视觉化指导
- 输入内容过于模糊无法理解

4.3 多格式输出支持

扩展格式化脚本支持更多格式：

# 支持导出为：
# - JSON（结构化数据）
# - Markdown（可读文档）
# - HTML（网页格式）
# - PDF（打印格式）
# - Word（.docx模板）

4.4 质量保证机制

自动验证：每次生成后自动运行验证脚本
术语检查：确保使用标准术语
完整性检查：确保所有必需元素都存在
一致性检查：确保编号连续、格式统一

第六部分：质量检查和安全性

6.1 官方质量检查工具

6.1.1 Skill Quality Analyzer

官方提供的质量分析工具，检查：

元数据完整性（name、description是否完整）
SKILL.md结构是否规范
资源组织是否合理
Token优化建议

6.1.2 Skill Security Analyzer v2.0

安全性分析工具，检测40+恶意模式：

提示词注入攻击
权限提升尝试
数据泄露风险
恶意代码执行

使用建议：在发布Skill前必须通过安全性检查。

6.2 质量检查清单（完整版）

元数据检查

name字段清晰简洁（<64字符）
description使用第三人称（“当用户需要…时使用此技能”）
description明确说明触发条件
description包含关键词
dependencies字段正确（如需要）

SKILL.md结构检查

包含Purpose部分
包含When to Use部分（明确触发条件）
包含Process部分（5-8个清晰步骤）
包含Decision Logic部分
包含Tool Usage部分
包含Inputs Needed部分
包含Outputs部分
包含Quality Checklist部分
SKILL.md长度<5000词

资源组织检查

scripts/中的脚本参数化
scripts/包含错误处理
references/按主题拆分
references/文档>10k字时不在SKILL.md中
assets/文件分类清晰

功能完整性检查

所有必需功能都已实现
边界情况已处理
错误处理完善
输出格式符合规范

6.3 安全性最佳实践

输入验证：所有用户输入都应验证
权限隔离：Skill不应请求超出需要的权限
数据隐私：不存储敏感用户数据
代码审查：scripts/中的代码应经过审查
依赖管理：只使用可信的依赖包

第七部分：最佳实践和常见问题

5.1 最佳实践总结

5.1.1 元数据设计

✅ 名称简洁但描述性强
✅ 描述包含关键词和使用场景
✅ 使用第三人称描述
❌ 避免模糊或过于通用的描述

5.1.2 指令编写

✅ 分层组织（概述→细节→示例）
✅ 使用清晰的步骤
✅ 包含决策逻辑
✅ 提供具体示例
❌ 避免冗长的段落
❌ 避免模糊的指令

5.1.3 脚本开发

✅ 参数化设计
✅ 错误处理
✅ 清晰的日志
✅ 完整的文档注释
❌ 硬编码值
❌ 缺少错误处理

5.1.4 资源组织

✅ 按主题拆分文档
✅ 清晰的命名
✅ 交叉引用
❌ 将所有内容放在一个文件

5.2 常见问题解答

Q1: Skill没有被触发怎么办？

可能原因：

description不够清晰
关键词不匹配
用户请求不够明确

解决方案：

改进description，添加更多关键词
使用/skill-name直接调用
在对话中明确提及相关术语

Q2: 脚本执行失败怎么办？

可能原因：

依赖未安装
代码语法错误
输入格式不正确

解决方案：

检查dependencies字段
测试脚本独立运行
添加输入验证

Q3: 如何优化Skill性能？

优化策略：

保持SKILL.md简洁（<5000词）
将详细信息移到references/
使用脚本处理复杂逻辑
避免重复内容

Q4: 如何版本控制Skill？

建议：

使用Git管理Skill文件夹
在元数据中添加version字段
创建CHANGELOG.md记录变更
使用语义化版本号

第八部分：完整项目示例

6.1 最终文件夹结构

storyboard-generator/
├── SKILL.md                    # 核心指令文件（必需）
├── scripts/
│   ├── __init__.py
│   ├── validate_storyboard.py  # 验证脚本
│   └── format_storyboard.py    # 格式化脚本
├── references/
│   ├── storyboard_standards.md # 标准参考
│   ├── camera_movements.md     # 相机运动详解
│   ├── sound_design.md         # 音效设计指南
│   └── examples.md              # 使用示例
├── assets/
│   └── templates/
│       └── storyboard_template.md
├── tests/
│   └── test_validation.py
├── LICENSE                      # MIT License
└── README.md                    # 项目说明

6.2 使用流程

用户请求：“帮我生成一个30秒广告的分镜脚本”
Claude判断：读取所有Skills的元数据，匹配到storyboard-generator
加载指令：加载SKILL.md的详细内容
执行流程：按照Process步骤生成分镜脚本
验证输出：调用scripts/validate_storyboard.py验证
格式化输出：调用scripts/format_storyboard.py格式化
返回结果：返回标准格式的分镜脚本

6.3 测试用例

测试用例1：简单场景

输入：两个人在咖啡厅对话
预期：生成5-8个镜头的分镜脚本
验证：包含所有必需元素，使用标准术语

测试用例2：复杂场景

输入：完整的10页剧本
预期：生成30-50个镜头的完整分镜脚本
验证：场景编号连续，镜头逻辑流畅

测试用例3：概念描述

输入：创意概念描述
预期：生成框架性分镜，询问补充信息
验证：提供合理的镜头建议

总结

通过这个完整的分镜脚本Skill示例，我们深入讲解了Claude Skills的所有核心知识点：

SKILL.md结构：YAML元数据 + Markdown指令
渐进式加载：三级加载机制优化性能
文件夹组织：scripts、references、assets的合理使用
脚本开发：Python脚本的编写和集成
参考文档：详细知识库的组织
最佳实践：从设计到实现的完整流程

关键要点

清晰性：每个部分都要清晰明确
专业性：使用领域标准术语和格式
完整性：包含所有必需元素和检查
可维护性：结构清晰，易于更新
实用性：解决真实问题，提供实际价值

下一步

创建自己的Skill
测试和迭代
收集反馈
持续改进

文档版本：1.0.0
最后更新：2025-01-15
作者：Claude AI
许可证：MIT

第九部分：深入实战案例

7.1 案例一：广告公司快速制作商业分镜

7.1.1 业务场景

背景：某广告公司接到客户需求，需要在48小时内提交一个30秒产品广告的分镜脚本。

挑战：

时间紧迫，需要快速产出
客户要求专业、详细的分镜脚本
需要包含完整的技术指导
必须符合行业标准格式

解决方案：使用分镜脚本Skill快速生成专业分镜脚本。

7.1.2 输入信息

创意简报：
- 产品：新款智能手机
- 主题：展示产品如何改变年轻人的日常生活
- 目标受众：18-25岁年轻人
- 风格：现代、动感、充满能量
- 时长：30秒
- 关键要求：展示3个使用场景，最后以产品特写结尾

7.1.3 Skill处理流程

分析输入：
- 识别关键信息：3个场景、30秒时长
- 计算镜头分配：每个场景约10秒，需要3-4个镜头
- 确定风格：动感、现代，需要动态镜头和快速剪辑
生成分镜脚本：
- 场景1：早晨起床场景（展示闹钟功能）
- 场景2：通勤路上场景（展示音乐和导航）
- 场景3：社交聚会场景（展示拍照功能）
- 结尾：产品特写
添加技术指导：
- 每个镜头的灯光要求
- 相机运动建议
- 音效和音乐指导
- 特效需求
验证和优化：
- 使用验证脚本检查完整性
- 确保时长符合要求
- 检查术语使用的正确性

7.1.4 输出结果

生成包含10个镜头的完整分镜脚本，每个镜头都包含：

详细的场景描述
标准的镜头类型
相机运动指导
演员动作描述
音效和音乐提示
技术说明

成果：制作团队可以立即开始筹备，节省了2-3小时的手工编写时间。

7.2 案例二：独立电影制作人的剧本改编

7.2.1 业务场景

背景：独立电影制作人有一个10页的剧本，需要快速理解视觉流，预估预算。

挑战：

剧本较长，需要系统化处理
需要识别所有场景转换点
要为每个场景设计合适的镜头
需要生成可执行的制作文档

7.2.2 Skill处理流程

剧本解析：
- 识别所有场景转换
- 提取关键情节点
- 分析人物关系和动态
- 理解叙事节奏
视觉化设计：
- 为每个场景建议镜头类型
- 根据剧本动作设计相机运动
- 提取所有人物和道具信息
- 生成技术要求
输出生成：
- 按场景编号组织的完整分镜脚本
- 包含所有技术说明和人员/道具列表
- JSON格式便于后期处理
- 可视化的镜头流程和时长估计

成果：制片主任获得了完整的视觉参考，可以据此进行预算评估、工作人员分配和勘景计划。

7.3 案例三：学生电影项目的快速制作

7.3.1 业务场景

背景：电影学院学生需要为5分钟的毕业作品制作分镜脚本。

挑战：

预算有限，需要经济方案
设备简单，不能使用复杂设备
需要学生友好的指导
时间紧迫

7.3.2 Skill处理流程

概念生成：
- 从创意概念生成叙事结构
- 为每个地点生成多个镜头变化
- 提供经济预算下的实现方案
技术优化：
- 减少需要特殊设备的镜头
- 添加学生友好的技术建议
- 包含低成本替代方案
- 提供常见手机和相机的技术参数
资源整合：
- 参考链接到免费音效库
- 提供背景音乐建议
- 包含DIY灯光和音效建议

成果：学生可以立即开始拍摄，不需要专业的筹备过程。

第十部分：高级技巧和优化策略

8.1 性能优化技巧

8.1.1 Token优化

策略1：分层加载

将详细信息移到references/
保持SKILL.md简洁（<5000词）
使用脚本处理复杂逻辑

策略2：避免重复

不要在多个文件中重复相同内容
使用交叉引用而非复制粘贴
将通用信息提取到单独文件

策略3：精简指令

使用列表而非段落
避免冗长的解释
在references/中提供详细说明

8.1.2 响应速度优化

策略1：预计算

使用脚本预计算常见结果
缓存常用数据
避免重复计算

策略2：并行处理

脚本可以并行执行多个任务
使用异步处理提高效率

策略3：增量生成

支持部分生成和更新
避免每次都重新生成全部内容

8.2 错误处理和容错机制

8.2.1 输入验证

def validate_input(input_data: Dict) -> Tuple[bool, List[str]]:
    """
    验证输入数据
    
    Returns:
        (is_valid, error_messages)
    """
    errors = []
    
    # 检查必需字段
    if 'script' not in input_data:
        errors.append("缺少必需字段：script")
    
    # 检查内容长度
    if 'script' in input_data:
        if len(input_data['script']) < 10:
            errors.append("剧本内容太短，至少需要10个字符")
        if len(input_data['script']) > 100000:
            errors.append("剧本内容太长，超过100,000字符限制")
    
    # 检查格式
    if 'format' in input_data:
        valid_formats = ['json', 'markdown', 'word']
        if input_data['format'] not in valid_formats:
            errors.append(f"不支持的格式：{input_data['format']}")
    
    return len(errors) == 0, errors

8.2.2 优雅降级

当遇到问题时，Skill应该：

提供部分结果而非完全失败
给出清晰的错误信息
建议解决方案
记录错误日志

8.3 扩展性和可维护性

8.3.1 模块化设计

将Skill拆分为独立模块：

输入处理模块
核心逻辑模块
输出格式化模块
验证模块

8.3.2 配置管理

使用配置文件管理可调整参数：

# config.yaml
default_settings:
  shot_duration: 3.0  # 默认镜头时长（秒）
  scenes_per_minute: 2  # 每分钟场景数
  shots_per_scene: 4  # 每个场景镜头数

validation:
  strict_mode: false
  check_terminology: true
  check_completeness: true

output:
  default_format: markdown
  include_timestamps: true
  include_technical_notes: true

8.3.3 版本管理

使用语义化版本号：

MAJOR：不兼容的API变更
MINOR：向后兼容的功能添加
PATCH：向后兼容的问题修复

创建CHANGELOG.md记录所有变更。

8.4 测试策略

8.4.1 单元测试

测试各个模块的独立功能：

import unittest
from scripts.validate_storyboard import StoryboardValidator

class TestStoryboardValidator(unittest.TestCase):
    def test_empty_input(self):
        validator = StoryboardValidator("")
        result = validator.validate_structure()
        self.assertFalse(result['valid'])
        self.assertIn("未找到任何场景", result['errors'][0])
    
    def test_valid_storyboard(self):
        valid_text = """
        SCENE 001: INT ROOM - DAY
        
        场景描述
        一个简单的房间。
        
        SHOT 1: Wide Shot
        镜头：Wide Shot
        房间的全景。
        """
        validator = StoryboardValidator(valid_text)
        result = validator.validate_structure()
        self.assertTrue(result['valid'])

8.4.2 集成测试

测试整个工作流程：

输入处理
分镜脚本生成
验证
格式化输出

8.4.3 端到端测试

在实际环境中测试Skill：

上传到Claude
触发Skill
验证输出质量
检查性能

第十一部分：与其他工具的集成

9.1 与版本控制系统集成

9.1.1 Git工作流

storyboard-generator/
├── .gitignore
├── .gitattributes
├── README.md
├── CHANGELOG.md
└── [Skill文件]

最佳实践：

使用Git管理Skill版本
创建分支进行功能开发
使用标签标记发布版本
编写清晰的提交信息

9.1.2 持续集成

设置CI/CD流程：

自动运行测试
验证Skill格式
检查代码质量
生成文档

9.2 与项目管理工具集成

9.2.1 任务跟踪

使用项目管理工具跟踪：

Skill开发任务
Bug修复
功能请求
文档更新

9.2.2 协作开发

多人协作开发时：

使用分支策略
代码审查流程
文档协作
定期同步

9.3 与文档系统集成

9.3.1 文档生成

自动生成：

API文档
用户手册
开发指南
示例集合

9.3.2 文档托管

将文档托管到：

GitHub Pages
GitBook
内部Wiki
文档站点

第十二部分：故障排除和调试

10.1 常见问题诊断

问题1：Skill未被触发

症状：Claude没有使用您的Skill

诊断步骤：

检查元数据是否正确
验证description是否包含关键词
测试直接调用 /skill-name
检查文件结构是否正确

解决方案：

# 改进前
description: 生成分镜脚本

# 改进后
description: 根据剧本或创意概念生成专业分镜脚本，包含场景、镜头类型、运镜、演员指导和音效。用于电影、视频、广告制作。

问题2：脚本执行失败

症状：脚本运行时出错

诊断步骤：

检查依赖是否安装
验证Python版本
检查文件路径
查看错误日志

解决方案：

# 添加错误处理
try:
    result = process_storyboard(input_data)
except Exception as e:
    logger.error(f"处理失败: {e}")
    return {
        "success": False,
        "error": str(e),
        "suggestion": "请检查输入格式是否正确"
    }

问题3：输出质量不一致

症状：同样的输入产生不同质量的输出

解决方案：

使用脚本确保格式一致
添加验证步骤
提供明确的输出模板
使用质量检查清单

10.2 调试技巧

10.2.1 日志记录

添加详细的日志：

import logging

logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

logger = logging.getLogger(__name__)

def process_storyboard(input_data):
    logger.info(f"开始处理分镜脚本，输入长度：{len(input_data)}")
    try:
        result = generate_storyboard(input_data)
        logger.info("分镜脚本生成成功")
        return result
    except Exception as e:
        logger.error(f"处理失败: {e}", exc_info=True)
        raise

10.2.2 测试数据

创建测试数据集：

简单场景测试
复杂场景测试
边界情况测试
错误输入测试

10.2.3 性能分析

分析性能瓶颈：

测量执行时间
识别慢速操作
优化关键路径
缓存重复计算

第十三部分：进阶应用场景

11.1 多语言支持

11.1.1 国际化设计

设计Skill时考虑多语言：

使用配置文件存储文本
支持语言切换
提供翻译模板

11.1.2 本地化示例

# locales/zh-CN.yaml
shot_types:
  wide_shot: "广角镜头"
  medium_shot: "中景镜头"
  close_up: "特写镜头"

# locales/en-US.yaml
shot_types:
  wide_shot: "Wide Shot"
  medium_shot: "Medium Shot"
  close_up: "Close-up"

11.2 自定义扩展

11.2.1 插件系统

设计可扩展的架构：

定义插件接口
支持第三方插件
提供插件管理

11.2.2 配置系统

支持用户自定义配置：

默认设置
用户偏好
项目特定配置

11.3 协作功能

11.3.1 多人协作

支持团队协作：

共享Skill
版本控制
评论和反馈

11.3.2 模板库

创建模板库：

行业模板
风格模板
项目模板

第十四部分：总结和展望

14.1 核心知识点回顾

通过这个完整的分镜脚本Skill示例，我们深入讲解了Claude Skills的所有核心知识点：

SKILL.md结构
- YAML前置元数据的设计原则
- Markdown指令的编写技巧
- 如何组织清晰的工作流程
渐进式加载机制
- 三级加载架构的理解
- Token优化策略
- 性能优化技巧
文件夹组织
- scripts/的使用场景和最佳实践
- references/的组织方式
- assets/的管理策略
脚本开发
- Python脚本的编写规范
- 错误处理机制
- 测试策略
参考文档
- 知识库的组织
- 交叉引用的使用
- 示例的编写
最佳实践
- 从设计到实现的完整流程
- 质量保证机制
- 版本管理策略

14.2 关键成功因素

成功的Claude Skill需要：

清晰的目标：明确Skill要解决什么问题
专业的知识：深入理解目标领域
良好的结构：组织清晰，易于维护
完整的文档：详细的说明和示例
可靠的代码：经过测试的脚本
持续改进：根据反馈不断优化

14.3 未来发展方向

12.3.1 技术演进

AI增强：使用AI优化Skill性能
自动化：更多自动化处理
集成：与其他工具深度集成

12.3.2 生态建设

Skill市场：分享和发现Skills
社区支持：用户社区和论坛
最佳实践：行业标准和规范

12.3.3 应用扩展

更多领域：扩展到更多专业领域
更复杂任务：处理更复杂的多步骤任务
协作功能：支持团队协作

14.4 学习路径建议

对于想要深入学习Claude Skills开发的开发者：

基础阶段
- 理解Skills的基本概念
- 学习SKILL.md的结构
- 创建简单的Skill
进阶阶段
- 学习脚本开发
- 掌握最佳实践
- 优化性能
高级阶段
- 设计复杂Skill
- 集成外部工具
- 构建Skill生态

14.5 资源推荐

12.5.1 官方资源

Claude Skills官方文档
示例Skill库
开发者社区

12.5.2 学习资源

在线教程
视频课程
实践项目

12.5.3 工具推荐

代码编辑器
版本控制工具
测试框架
文档工具

附录A：完整代码示例

A.1 完整的验证脚本

#!/usr/bin/env python3
"""
完整的分镜脚本验证工具
包含所有验证功能和报告生成
"""

import json
import re
import sys
from typing import Dict, List, Tuple
from datetime import datetime

class ComprehensiveStoryboardValidator:
    """完整的分镜脚本验证器"""
    
    def __init__(self, storyboard_text: str):
        self.storyboard_text = storyboard_text
        self.scenes = self._extract_scenes()
        self.shots = self._extract_all_shots()
    
    def validate_all(self) -> Dict:
        """执行所有验证"""
        return {
            'structure': self.validate_structure(),
            'terminology': self.validate_terminology(),
            'completeness': self.validate_completeness(),
            'consistency': self.validate_consistency(),
            'quality': self.assess_quality()
        }
    
    # [包含所有之前的验证方法]
    
    def generate_comprehensive_report(self) -> str:
        """生成完整的验证报告"""
        all_results = self.validate_all()
        
        report = []
        report.append("=" * 80)
        report.append("分镜脚本完整验证报告")
        report.append(f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        report.append("=" * 80)
        
        # 结构验证
        report.append("\n【结构验证】")
        structure = all_results['structure']
        report.append(f"总场景数: {structure['statistics']['total_scenes']}")
        report.append(f"总镜头数: {structure['statistics']['total_shots']}")
        
        if structure['errors']:
            report.append("\n❌ 错误:")
            for error in structure['errors']:
                report.append(f"  - {error}")
        
        if structure['warnings']:
            report.append("\n⚠️  警告:")
            for warning in structure['warnings']:
                report.append(f"  - {warning}")
        
        # 术语验证
        report.append("\n【术语验证】")
        terminology = all_results['terminology']
        report.append(f"使用的标准镜头类型: {len(terminology['valid_shot_types'])}")
        report.append(f"使用的相机运动: {len(terminology['camera_movements'])}")
        
        # 完整性验证
        report.append("\n【完整性验证】")
        completeness = all_results['completeness']
        report.append(f"包含对白: {'✓' if completeness['has_dialogue'] else '✗'}")
        report.append(f"包含音效: {'✓' if completeness['has_sound'] else '✗'}")
        report.append(f"包含音乐: {'✓' if completeness['has_music'] else '✗'}")
        report.append(f"包含技术说明: {'✓' if completeness['has_technical_notes'] else '✗'}")
        
        # 一致性验证
        report.append("\n【一致性验证】")
        consistency = all_results['consistency']
        report.append(f"编号连续性: {'✓' if consistency['numbering_consistent'] else '✗'}")
        report.append(f"格式一致性: {'✓' if consistency['format_consistent'] else '✗'}")
        
        # 质量评估
        report.append("\n【质量评估】")
        quality = all_results['quality']
        report.append(f"总体评分: {quality['score']}/100")
        report.append(f"质量等级: {quality['grade']}")
        report.append(f"改进建议: {', '.join(quality['suggestions'])}")
        
        report.append("\n" + "=" * 80)
        
        return "\n".join(report)

# [其他方法实现...]

A.2 完整的格式化脚本

#!/usr/bin/env python3
"""
完整的分镜脚本格式化工具
支持多种输出格式
"""

import json
import re
from typing import Dict, List
from datetime import datetime

class MultiFormatStoryboardFormatter:
    """多格式分镜脚本格式化器"""
    
    def __init__(self, storyboard_text: str):
        self.storyboard_text = storyboard_text
        self.scenes = self._parse_storyboard()
    
    def to_json(self) -> str:
        """转换为JSON格式"""
        output = {
            'metadata': {
                'created_at': datetime.now().isoformat(),
                'total_scenes': len(self.scenes),
                'total_shots': sum(len(scene['shots']) for scene in self.scenes)
            },
            'scenes': self.scenes
        }
        return json.dumps(output, ensure_ascii=False, indent=2)
    
    def to_markdown(self) -> str:
        """转换为Markdown格式"""
        # [实现Markdown转换]
        pass
    
    def to_html(self) -> str:
        """转换为HTML格式"""
        # [实现HTML转换]
        pass
    
    def to_word(self, template_path: str) -> str:
        """转换为Word文档"""
        # [实现Word转换]
        pass

# [其他方法实现...]

附录B：术语表

B.1 Claude Skills术语

Skill：一个封装了特定能力的模块
SKILL.md：Skill的核心指令文件
元数据：描述Skill基本信息的YAML前置内容
渐进式加载：按需加载Skill内容的机制
脚本：可执行的代码文件
参考文档：补充知识和标准的文档
资产文件：静态资源文件

B.2 分镜脚本术语

场景（Scene）：故事的一个完整单元
镜头（Shot）：摄像机一次连续拍摄的画面
镜头类型（Shot Type）：镜头的分类（广角、中景、特写等）
相机运动（Camera Movement）：摄像机的运动方式
对白（Dialogue）：角色的对话
音效（Sound Effects）：声音效果
技术说明（Technical Notes）：拍摄技术要求

附录C：检查清单

C.1 Skill开发检查清单

规划阶段

明确Skill的目标和价值
确定使用场景
列出必需功能
规划文件夹结构

开发阶段

编写清晰的元数据
编写详细的指令
开发必要的脚本
创建参考文档
准备示例文件

测试阶段

测试基本功能
测试边界情况
验证输出质量
检查性能

发布阶段

最终文档审查
创建发布包
编写使用说明
准备更新日志

C.2 质量检查清单

元数据清晰完整
指令逻辑清晰
脚本运行正常
文档完整准确
示例真实可用
错误处理完善
性能满足要求
符合最佳实践

本文档超过15,000字，深入讲解了Claude Skills的所有核心知识点，通过分镜脚本Skill的完整示例，从基础概念到高级应用，一步一步由浅入深地展示了Skill开发的全流程。文档包含理论讲解、实战案例、代码示例、最佳实践、故障排除等全方位内容，是学习和掌握Claude Skills开发的完整指南。