docs(template): 添加产品和需求调研文档模板

- 新增产品调研模板，包含市场调研、用户调研、竞品分析等内容
- 新增需求调研模板，涵盖用户访谈、业务流程分析、场景分析等
- 在adapter和skills目录下同步添加模板文件
- 更新.gitignore文件以忽略临时文件和输出目录

.claude-plugin/marketplace.json

@@ -0,0 +1,93 @@
+{
+  "name": "teaching-ai-skills",
+  "owner": {
+    "name": "TeachingAI",
+    "email": "teachingai@163.com"
+  },
+  "metadata": {
+    "description": "Teaching AI 免费技能市场 - 提供各种实用的 AI 技能集合，包括教学、开发、设计、文档处理等",
+    "version": "1.0.0"
+  },
+  "plugins": [
+    {
+      "name": "teaching-skills",
+      "description": "教学与教育相关技能集合，包括课程设计、学习评估、教学资源生成等",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/course-designer",
+        "./skills/learning-assessor",
+        "./skills/teaching-resource-generator"
+      ]
+    },
+    {
+      "name": "document-skills",
+      "description": "文档处理技能集合，支持 Excel、Word、PowerPoint、PDF 等办公文档的创建、编辑和处理",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/docx",
+        "./skills/pptx",
+        "./skills/pdf",
+        "./skills/xlsx",
+        "./skills/doc-coauthoring"
+      ]
+    },
+    {
+      "name": "markdown-skills",
+      "description": "Markdown 相关技能集合，包括 Mermaid 图表绘制等",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/mermaid"
+      ]
+    },
+    {
+      "name": "development-skills",
+      "description": "开发技能集合，包括代码生成、测试编写、文档构建、项目文档生成、MCP 构建器、Web 开发、前端设计等",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/code-generator",
+        "./skills/test-writer",
+        "./skills/documentation-builder",
+        "./skills/zh-product-doc-generator",
+        "./skills/mcp-builder",
+        "./skills/webapp-testing",
+        "./skills/frontend-design",
+        "./skills/web-artifacts-builder",
+        "./skills/theme-factory"
+      ]
+    },
+    {
+      "name": "design-skills",
+      "description": "设计与创意技能集合，包括算法艺术、品牌指南、画布设计等",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/algorithmic-art",
+        "./skills/brand-guidelines",
+        "./skills/canvas-design"
+      ]
+    },
+    {
+      "name": "social-skills",
+      "description": "社交与协作技能集合，包括内部沟通、Slack GIF 创建等",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/internal-comms",
+        "./skills/slack-gif-creator"
+      ]
+    },
+    {
+      "name": "utility-skills",
+      "description": "工具与实用技能集合，包括技能创建器等",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/skill-creator"
+      ]
+    }
+  ]
+}

.claude-plugin/marketplace.json.back

@@ -0,0 +1,45 @@
+{
+  "name": "anthropic-agent-skills",
+  "owner": {
+    "name": "Keith Lazuka",
+    "email": "klazuka@anthropic.com"
+  },
+  "metadata": {
+    "description": "Anthropic example skills",
+    "version": "1.0.0"
+  },
+  "plugins": [
+    {
+      "name": "document-skills",
+      "description": "Collection of document processing suite including Excel, Word, PowerPoint, and PDF capabilities",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/xlsx",
+        "./skills/docx",
+        "./skills/pptx",
+        "./skills/pdf"
+      ]
+    },
+    {
+      "name": "example-skills",
+      "description": "Collection of example skills demonstrating various capabilities including skill creation, MCP building, visual design, algorithmic art, internal communications, web testing, artifact building, Slack GIFs, and theme styling",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/algorithmic-art",
+        "./skills/brand-guidelines",
+        "./skills/canvas-design",
+        "./skills/doc-coauthoring",
+        "./skills/frontend-design",
+        "./skills/internal-comms",
+        "./skills/mcp-builder",
+        "./skills/skill-creator",
+        "./skills/slack-gif-creator",
+        "./skills/theme-factory",
+        "./skills/web-artifacts-builder",
+        "./skills/webapp-testing"
+      ]
+    }
+  ]
+}

.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+__pycache__/
+.idea/
+.vscode/
+

AGENTS.md

@@ -0,0 +1,111 @@
+# AGENTS.md
+
+本文档为 AI 编码智能体（Claude Code、Cursor、Copilot 等）在本仓库中工作时提供指导。
+
+## 仓库概览
+
+面向 Claude.ai 与 Claude Code 的一组技能集合，用于处理与 Vercel 部署相关的工作。技能是经过打包的说明与脚本，用于扩展 Claude 的能力。
+
+## 创建新技能
+
+### 目录结构
+
+```
+skills/
+  {skill-name}/           # kebab-case directory name
+    SKILL.md              # Required: skill definition
+    scripts/              # Required: executable scripts
+      {script-name}.sh    # Bash scripts (preferred)
+  {skill-name}.zip        # Required: packaged for distribution
+```
+
+### 命名规范
+
+- **技能目录**：`kebab-case`（例如 `vercel-deploy`、`log-monitor`）
+- **SKILL.md**：始终使用全大写，且文件名必须严格为 `SKILL.md`
+- **脚本**：`kebab-case.sh`（例如 `deploy.sh`、`fetch-logs.sh`）
+- **Zip 文件**：必须与目录名严格一致：`{skill-name}.zip`
+
+### SKILL.md 格式
+
+```markdown
+---
+name: {skill-name}
+description: {One sentence describing when to use this skill. Include trigger phrases like "Deploy my app", "Check logs", etc.}
+---
+
+# {Skill Title}
+
+{Brief description of what the skill does.}
+
+## How It Works
+
+{Numbered list explaining the skill's workflow}
+
+## Usage
+
+```bash
+bash /mnt/skills/user/{skill-name}/scripts/{script}.sh [args]
+```
+
+**Arguments:**
+- `arg1` - Description (defaults to X)
+
+**Examples:**
+{Show 2-3 common usage patterns}
+
+## Output
+
+{Show example output users will see}
+
+## Present Results to User
+
+{Template for how Claude should format results when presenting to users}
+
+## Troubleshooting
+
+{Common issues and solutions, especially network/permissions errors}
+```
+
+### 上下文效率最佳实践
+
+技能按需加载——启动时只加载技能名称与描述。只有当智能体判断某个技能相关时，完整的 `SKILL.md` 才会进入上下文。为减少上下文占用：
+
+- **将 SKILL.md 控制在 500 行以内**——详细参考资料放在单独文件中
+- **描述写得具体**——帮助智能体准确判断何时激活技能
+- **渐进式披露**——引用支撑文件，仅在需要时再读取
+- **优先用脚本而不是内联代码**——执行脚本不会占用上下文（只有输出会占用）
+- **文件引用只支持一层深度**——从 SKILL.md 直接链接到支撑文件
+
+### 脚本要求
+
+- 使用 `#!/bin/bash` shebang
+- 使用 `set -e` 实现失败即退出
+- 将状态信息输出到 stderr：`echo "Message" >&2`
+- 将机器可读输出（JSON）写入 stdout
+- 为临时文件加入 cleanup trap
+- 脚本路径引用格式为 `/mnt/skills/user/{skill-name}/scripts/{script}.sh`
+
+### 创建 Zip 包
+
+创建或更新技能后：
+
+```bash
+cd skills
+zip -r {skill-name}.zip {skill-name}/
+```
+
+### 终端用户安装
+
+为用户记录以下两种安装方式：
+
+**Claude Code：**
+```bash
+cp -r skills/{skill-name} ~/.claude/skills/
+```
+
+**claude.ai：**
+将技能加入项目知识，或将 SKILL.md 内容粘贴到对话中。
+
+如果技能需要网络访问，提示用户在 `claude.ai/admin-settings/capabilities` 中添加所需域名。
+

AGENTS_EN.md

@@ -0,0 +1,110 @@
+# AGENTS.md
+
+This file provides guidance to AI coding agents (Claude Code, Cursor, Copilot, etc.) when working with code in this repository.
+
+## Repository Overview
+
+A collection of skills for Claude.ai and Claude Code for working with Vercel deployments. Skills are packaged instructions and scripts that extend Claude's capabilities.
+
+## Creating a New Skill
+
+### Directory Structure
+
+```
+skills/
+  {skill-name}/           # kebab-case directory name
+    SKILL.md              # Required: skill definition
+    scripts/              # Required: executable scripts
+      {script-name}.sh    # Bash scripts (preferred)
+  {skill-name}.zip        # Required: packaged for distribution
+```
+
+### Naming Conventions
+
+- **Skill directory**: `kebab-case` (e.g., `vercel-deploy`, `log-monitor`)
+- **SKILL.md**: Always uppercase, always this exact filename
+- **Scripts**: `kebab-case.sh` (e.g., `deploy.sh`, `fetch-logs.sh`)
+- **Zip file**: Must match directory name exactly: `{skill-name}.zip`
+
+### SKILL.md Format
+
+```markdown
+---
+name: {skill-name}
+description: {One sentence describing when to use this skill. Include trigger phrases like "Deploy my app", "Check logs", etc.}
+---
+
+# {Skill Title}
+
+{Brief description of what the skill does.}
+
+## How It Works
+
+{Numbered list explaining the skill's workflow}
+
+## Usage
+
+```bash
+bash /mnt/skills/user/{skill-name}/scripts/{script}.sh [args]
+```
+
+**Arguments:**
+- `arg1` - Description (defaults to X)
+
+**Examples:**
+{Show 2-3 common usage patterns}
+
+## Output
+
+{Show example output users will see}
+
+## Present Results to User
+
+{Template for how Claude should format results when presenting to users}
+
+## Troubleshooting
+
+{Common issues and solutions, especially network/permissions errors}
+```
+
+### Best Practices for Context Efficiency
+
+Skills are loaded on-demand — only the skill name and description are loaded at startup. The full `SKILL.md` loads into context only when the agent decides the skill is relevant. To minimize context usage:
+
+- **Keep SKILL.md under 500 lines** — put detailed reference material in separate files
+- **Write specific descriptions** — helps the agent know exactly when to activate the skill
+- **Use progressive disclosure** — reference supporting files that get read only when needed
+- **Prefer scripts over inline code** — script execution doesn't consume context (only output does)
+- **File references work one level deep** — link directly from SKILL.md to supporting files
+
+### Script Requirements
+
+- Use `#!/bin/bash` shebang
+- Use `set -e` for fail-fast behavior
+- Write status messages to stderr: `echo "Message" >&2`
+- Write machine-readable output (JSON) to stdout
+- Include a cleanup trap for temp files
+- Reference the script path as `/mnt/skills/user/{skill-name}/scripts/{script}.sh`
+
+### Creating the Zip Package
+
+After creating or updating a skill:
+
+```bash
+cd skills
+zip -r {skill-name}.zip {skill-name}/
+```
+
+### End-User Installation
+
+Document these two installation methods for users:
+
+**Claude Code:**
+```bash
+cp -r skills/{skill-name} ~/.claude/skills/
+```
+
+**claude.ai:**
+Add the skill to project knowledge or paste SKILL.md contents into the conversation.
+
+If the skill requires network access, instruct users to add required domains at `claude.ai/admin-settings/capabilities`.

IMPLEMENTATION.md

@@ -0,0 +1,318 @@
+# Skills Marketplace 实现机制详解
+
+本文档详细说明 `/plugin marketplace add` 命令的实现机制，以及如何搭建自己的免费技能市场。
+
+## 核心机制
+
+### 1. 命令格式
+
+```
+/plugin marketplace add <github-username>/<repository-name>
+```
+
+例如：
+```
+/plugin marketplace add anthropics/skills
+/plugin marketplace add teaching-ai/skills
+```
+
+### 2. 工作原理
+
+当您在 Claude Code 中执行 `/plugin marketplace add` 命令时，系统会执行以下步骤：
+
+#### 步骤 1: 解析仓库信息
+
+系统解析命令中的 GitHub 仓库路径：
+- `anthropics/skills` → 用户名: `anthropics`, 仓库名: `skills`
+- 构建 GitHub API URL: `https://api.github.com/repos/anthropics/skills`
+
+#### 步骤 2: 获取 Marketplace 配置
+
+系统从 GitHub 仓库获取配置文件：
+- 路径: `.claude-plugin/marketplace.json`
+- URL: `https://raw.githubusercontent.com/anthropics/skills/main/.claude-plugin/marketplace.json`
+- 或通过 GitHub API: `https://api.github.com/repos/anthropics/skills/contents/.claude-plugin/marketplace.json`
+
+#### 步骤 3: 解析配置
+
+系统解析 `marketplace.json` 文件，获取：
+- Marketplace 名称和元数据
+- 可用的插件列表
+- 每个插件包含的技能列表
+
+#### 步骤 4: 注册 Marketplace
+
+系统将 marketplace 信息存储到本地配置中，使其可用于后续的插件安装。
+
+#### 步骤 5: 安装插件
+
+当用户安装插件时，系统会：
+1. 从 GitHub 仓库下载插件中定义的所有 skills
+2. 将 skills 存储到本地（通常在 `~/.claude/plugins/` 或类似位置）
+3. 使 skills 可用于 Claude
+
+## 配置文件结构
+
+### marketplace.json 格式
+
+```json
+{
+  "name": "marketplace-identifier",    // Marketplace 的唯一标识符
+  "owner": {                            // 所有者信息（可选）
+    "name": "Owner Name",
+    "email": "owner@example.com"
+  },
+  "metadata": {                          // 元数据
+    "description": "Marketplace 描述",
+    "version": "1.0.0"                   // 版本号
+  },
+  "plugins": [                           // 插件列表
+    {
+      "name": "plugin-identifier",       // 插件的唯一标识符
+      "description": "插件描述",
+      "source": "./",                    // 源代码根路径（相对于仓库根目录）
+      "strict": false,                   // 是否严格模式（通常为 false）
+      "skills": [                        // 技能路径列表（相对于 source）
+        "./skills/skill1",
+        "./skills/skill2"
+      ]
+    }
+  ]
+}
+```
+
+### 关键字段说明
+
+- **name**: Marketplace 的唯一标识符，用于在系统中识别
+- **plugins**: 插件数组，每个插件可以包含多个 skills
+- **source**: 源代码路径，通常为 `"./"`（仓库根目录）
+- **skills**: 技能路径数组，相对于 `source` 路径
+
+## Skill 结构
+
+### 目录结构
+
+每个 skill 是一个目录，必须包含 `SKILL.md` 文件：
+
+```
+skill-name/
+├── SKILL.md              # 必需：技能定义文件
+├── scripts/              # 可选：可执行脚本
+│   └── script.py
+├── references/           # 可选：参考文档
+│   └── reference.md
+└── assets/               # 可选：资源文件
+    └── template.html
+```
+
+### SKILL.md 格式
+
+每个 `SKILL.md` 文件必须包含：
+
+1. **YAML Frontmatter**（必需）:
+```yaml
+---
+name: skill-name          # 技能的唯一标识符（小写，使用连字符）
+description: 技能的简短描述，说明何时使用这个技能
+license: 许可证信息（可选）
+---
+```
+
+2. **Markdown 内容**（必需）:
+```markdown
+# 技能名称
+
+## 概述
+技能的详细说明...
+
+## 核心功能
+...
+
+## 使用指南
+...
+```
+
+### 关键要求
+
+- **name**: 必须是小写，使用连字符分隔（kebab-case）
+- **description**: 必须清晰描述何时使用该技能，这是 Claude 判断是否使用技能的主要依据
+- **SKILL.md**: 文件名必须严格为 `SKILL.md`（全大写）
+
+## 实现步骤
+
+### 1. 创建 GitHub 仓库
+
+1. 在 GitHub 上创建新仓库（例如：`teaching-ai/skills`）
+2. 确保仓库是公开的（public），这样 Claude Code 才能访问
+
+### 2. 创建目录结构
+
+```bash
+mkdir -p .claude-plugin
+mkdir -p skills/your-skill-name
+```
+
+### 3. 创建 marketplace.json
+
+在 `.claude-plugin/marketplace.json` 中定义 marketplace 配置。
+
+### 4. 创建 Skills
+
+为每个技能创建目录和 `SKILL.md` 文件。
+
+### 5. 提交到 GitHub
+
+```bash
+git add .
+git commit -m "Initial marketplace setup"
+git push origin main
+```
+
+### 6. 在 Claude Code 中使用
+
+```
+/plugin marketplace add teaching-ai/skills
+```
+
+## 技术细节
+
+### GitHub API 访问
+
+Claude Code 可能使用以下方式访问 GitHub 内容：
+
+1. **GitHub API**:
+   - 获取文件内容: `GET /repos/{owner}/{repo}/contents/{path}`
+   - 需要处理 Base64 编码的内容
+
+2. **Raw GitHub URLs**:
+   - 直接访问: `https://raw.githubusercontent.com/{owner}/{repo}/{branch}/{path}`
+   - 更简单，但需要知道分支名
+
+3. **GitHub CLI**:
+   - 使用 `gh` 命令获取内容
+
+### 本地存储
+
+安装的插件和 skills 通常存储在：
+- macOS/Linux: `~/.claude/plugins/` 或 `~/.config/claude/plugins/`
+- Windows: `%APPDATA%\claude\plugins\`
+
+### 技能加载机制
+
+1. **启动时**: 只加载所有技能的 `name` 和 `description`（从 frontmatter）
+2. **使用时**: 当 Claude 判断需要某个技能时，加载完整的 `SKILL.md` 内容
+3. **按需加载**: 脚本、参考文档等资源按需加载
+
+## 最佳实践
+
+### Marketplace 设计
+
+1. **清晰的命名**: 使用描述性的名称
+2. **逻辑分组**: 将相关技能组织到同一个插件中
+3. **版本管理**: 在 `metadata` 中维护版本号
+4. **文档完善**: 提供清晰的 README 和使用说明
+
+### Skill 设计
+
+1. **精确的描述**: `description` 字段应该准确描述何时使用该技能
+2. **简洁的内容**: 保持 `SKILL.md` 简洁，避免不必要的冗长
+3. **结构化组织**: 使用清晰的章节和结构
+4. **实用示例**: 提供实际可用的示例
+
+### 仓库管理
+
+1. **版本控制**: 使用 Git 进行版本控制
+2. **分支策略**: 使用 `main` 或 `master` 作为主分支
+3. **标签管理**: 使用 Git tags 标记版本
+4. **持续更新**: 定期更新和维护 skills
+
+## 故障排除
+
+### 常见问题
+
+1. **无法找到 marketplace.json**
+   - 检查文件路径是否正确：`.claude-plugin/marketplace.json`
+   - 确保文件已提交到 GitHub
+   - 检查仓库是否为公开仓库
+
+2. **技能无法加载**
+   - 检查 `SKILL.md` 文件是否存在
+   - 验证 YAML frontmatter 格式是否正确
+   - 确保技能路径在 `marketplace.json` 中正确配置
+
+3. **插件安装失败**
+   - 检查 GitHub 仓库访问权限
+   - 验证网络连接
+   - 查看 Claude Code 的错误日志
+
+## 扩展功能
+
+### 添加脚本支持
+
+在 skill 目录下创建 `scripts/` 目录，添加可执行脚本：
+
+```bash
+skills/your-skill/
+├── SKILL.md
+└── scripts/
+    └── process.py
+```
+
+在 `SKILL.md` 中引用脚本：
+
+```markdown
+## 使用脚本
+
+运行处理脚本：
+```bash
+python scripts/process.py [args]
+```
+```
+
+### 添加参考文档
+
+在 skill 目录下创建 `references/` 目录：
+
+```bash
+skills/your-skill/
+├── SKILL.md
+└── references/
+    └── api-reference.md
+```
+
+在 `SKILL.md` 中引用：
+
+```markdown
+## API 参考
+
+详细 API 文档请参考 [API Reference](references/api-reference.md)
+```
+
+### 添加资源文件
+
+在 skill 目录下创建 `assets/` 目录：
+
+```bash
+skills/your-skill/
+├── SKILL.md
+└── assets/
+    └── template.html
+```
+
+## 总结
+
+`/plugin marketplace add` 命令的实现机制相对简单：
+
+1. **解析命令**: 提取 GitHub 仓库信息
+2. **获取配置**: 从 GitHub 下载 `marketplace.json`
+3. **注册**: 将 marketplace 添加到本地配置
+4. **安装**: 下载并安装插件中的 skills
+
+要搭建自己的技能市场，只需要：
+1. 创建 GitHub 仓库
+2. 创建 `.claude-plugin/marketplace.json` 配置文件
+3. 创建 skills 目录和 `SKILL.md` 文件
+4. 提交到 GitHub
+5. 在 Claude Code 中使用 `/plugin marketplace add` 命令
+
+整个过程完全基于 GitHub 的公开仓库，无需额外的服务器或 API。

PLATFORM_GUIDE.md

@@ -0,0 +1,665 @@
+# 跨平台使用指南
+
+本指南说明如何将 Teaching AI Skills 在不同平台上使用，包括 Trae、Cursor、Qoder、CodeBuddy 等。
+
+## ⚠️ 重要说明
+
+**本指南中的适配方法为理论性指导，尚未经过实际验证。** 
+
+- 这些方法基于平台的一般特性和常见的适配模式
+- 不同平台的 API 和配置格式可能会有所不同
+- **建议在实际使用前：**
+  1. 查阅目标平台的官方文档
+  2. 在小范围内测试适配方案
+  3. 根据实际平台特性调整配置
+  4. 如有问题，欢迎通过 GitHub Issues 反馈
+
+## 概述
+
+Teaching AI Skills 遵循 [Agent Skills 标准](https://agentskills.io/)，这是一个开放的技能格式规范。虽然不同平台对 skills 的支持程度不同，但通过适当的适配，这些 skills 可以在多个平台上使用。
+
+## 平台支持情况
+
+### 1. Claude Code（原生支持）
+
+Claude Code 完全支持 Agent Skills 标准，可以直接使用 marketplace 方式安装。
+
+**安装方式：**
+```bash
+/plugin marketplace add teaching-ai/skills
+/plugin install teaching-skills@teaching-ai-skills
+```
+
+### 2. Claude.ai（原生支持）
+
+Claude.ai 的付费套餐支持直接上传和使用 skills。
+
+**使用方式：**
+1. 访问 Claude.ai 设置
+2. 上传 `SKILL.md` 文件或整个技能目录
+3. 在对话中直接使用技能
+
+### 3. Claude API（原生支持）
+
+通过 Claude API 可以上传和使用自定义 skills。
+
+**使用方式：**
+参考 [Skills API Quickstart](https://docs.claude.com/en/api/skills-guide#creating-a-skill)
+
+### 4. Cursor（部分支持）
+
+Cursor 是一个基于 AI 的代码编辑器，支持通过自定义指令和上下文文件来扩展 AI 能力。
+
+#### 适配方法
+
+**方法一：作为自定义指令使用**
+
+1. 将 `SKILL.md` 的内容转换为 Cursor 的自定义指令格式
+2. 在 Cursor 设置中添加为 `.cursorrules` 或自定义指令
+
+**步骤：**
+```bash
+# 1. 复制技能内容
+cp skills/course-designer/SKILL.md ~/.cursor/rules/course-designer.md
+
+# 2. 在 Cursor 设置中引用
+# Settings > Rules > Add Rule
+# 指向 ~/.cursor/rules/course-designer.md
+```
+
+**方法二：作为项目上下文使用**
+
+1. 将技能目录添加到项目根目录
+2. 在 `.cursorignore` 中排除不需要的文件
+3. Cursor 会自动读取项目中的 `SKILL.md` 文件
+
+**示例项目结构：**
+```
+my-project/
+├── .cursor/
+│   └── rules/
+│       └── teaching-skills.md
+├── skills/
+│   ├── course-designer/
+│   │   └── SKILL.md
+│   └── code-generator/
+│       └── SKILL.md
+└── .cursorignore
+```
+
+**方法三：转换为 Cursor Composer 指令**
+
+将技能的核心功能转换为 Cursor 的 Composer 指令模板：
+
+```markdown
+# Course Designer Skill for Cursor
+
+When the user asks about course design, curriculum planning, or educational content:
+
+1. Analyze the requirements
+2. Design course structure
+3. Create learning objectives
+4. Plan assessment methods
+
+[原 SKILL.md 的内容...]
+```
+
+### 5. Trae（需要适配）
+
+> **注意：** 以下适配方案为理论性建议，需要根据 Trae 平台的实际插件系统进行验证和调整。建议先查阅 Trae 的官方文档了解其插件机制。
+
+Trae 如果支持插件或扩展系统，可以通过以下方式适配：
+
+#### 适配步骤
+
+1. **检查平台插件格式**
+   - 查看 Trae 是否支持插件系统
+   - 了解插件 manifest 格式要求
+
+2. **转换技能格式**
+   - 将 `SKILL.md` 转换为 Trae 支持的格式
+   - 可能需要创建 `trae-plugin.json` 配置文件
+
+3. **处理依赖**
+   - 确保技能所需的脚本和资源可以被 Trae 访问
+   - 调整文件路径引用
+
+**示例适配：**
+```json
+// trae-plugin.json
+{
+  "name": "teaching-skills",
+  "version": "1.0.0",
+  "description": "Teaching and education skills",
+  "skills": [
+    {
+      "name": "course-designer",
+      "description": "Course design skill",
+      "instructions": "./skills/course-designer/SKILL.md"
+    }
+  ]
+}
+```
+
+### 6. Qoder（需要适配）
+
+[Qoder](https://qoder.com/) 是一个 **agentic coding platform**（代理式编程平台），支持端到端的编码流程，包括代码生成、调试、部署等阶段。Qoder 支持以 agent 的形式自动化编程任务。
+
+> **注意：** 以下适配方案基于 Qoder 作为 agentic platform 的一般特性，具体的 agent 配置格式、API 接口等需要查阅 Qoder 官方文档进行验证。示例配置格式仅供参考，实际格式可能有所不同。
+
+#### 适配方法
+
+由于 Qoder 是一个 agentic 平台，可以将 skills 适配为 Qoder 的 agent 模块：
+
+1. **转换为 Agent 模块**
+   - 将 `SKILL.md` 中的指令转换为 Qoder agent 的工作流程
+   - 定义 agent 的输入、输出和执行步骤
+   - 将技能的工作流程映射为 Qoder 的 agent 任务
+
+2. **创建 Agent 配置文件**
+   - 为每个技能创建 Qoder agent 配置文件
+   - 定义 agent 的能力和触发条件
+
+3. **部署到 Qoder 环境**
+   - 将技能代码和配置部署到 Qoder 可访问的位置
+   - 配置 agent 的权限和依赖
+
+**示例 Agent 配置：**
+```json
+// qoder-agent-config.json
+{
+  "name": "course-designer-agent",
+  "description": "Agent for designing courses and curricula",
+  "version": "1.0.0",
+  "capabilities": [
+    "course-design",
+    "curriculum-planning",
+    "learning-objective-creation"
+  ],
+  "workflow": [
+    {
+      "step": "analyze-requirements",
+      "description": "Analyze course requirements and constraints"
+    },
+    {
+      "step": "design-structure",
+      "description": "Design course structure and modules"
+    },
+    {
+      "step": "create-objectives",
+      "description": "Create learning objectives"
+    },
+    {
+      "step": "plan-assessments",
+      "description": "Plan assessment methods"
+    }
+  ],
+  "instructions": "./skills/course-designer/SKILL.md"
+}
+```
+
+**示例 Python Agent 模块：**
+```python
+# qoder_agent_module.py
+"""
+Course Designer Agent for Qoder
+"""
+class CourseDesignerAgent:
+    """
+    Agent for designing courses and educational content
+    """
+    def __init__(self):
+        self.name = "course-designer"
+        self.description = "Designs courses and curricula"
+    
+    def execute(self, task, context):
+        """
+        Execute course design task
+        """
+        # 读取 SKILL.md 中的指令
+        # 执行课程设计工作流
+        # 返回设计结果
+        pass
+    
+    def analyze_requirements(self, topic, duration, level):
+        """Analyze course requirements"""
+        pass
+    
+    def design_structure(self, requirements):
+        """Design course structure"""
+        pass
+```
+
+**适配步骤：**
+1. 检查 Qoder 的 agent 配置格式要求
+2. 将 `SKILL.md` 转换为 Qoder agent 指令
+3. 创建 agent 配置文件（JSON 或 YAML）
+4. 将技能资源部署到 Qoder 可访问的位置
+5. 在 Qoder 中注册和激活 agent
+
+### 7. Windsurf（需要适配）
+
+[Windsurf](https://windsurf.com/) 是一个 AI 驱动的代码编辑器，支持 Cascade Skills 系统。Windsurf 使用与 Agent Skills 相同的 SKILL.md 格式，转换相对简单。
+
+#### 适配方法
+
+由于 Windsurf 使用与 Agent Skills 相同的格式，转换主要是复制文件结构：
+
+1. **复制 SKILL.md**
+   - Windsurf 使用相同的 YAML frontmatter + Markdown 格式
+   - 可以直接使用原始的 SKILL.md 文件
+
+2. **复制资源文件**
+   - 自动复制 scripts、templates、references 等目录
+   - 保留技能的所有辅助资源
+
+3. **部署到 Windsurf**
+   - 项目级：放在 `.windsurf/skills/` 目录
+   - 全局级：放在 `~/.windsurf/skills/` 目录
+
+**适配步骤：**
+1. 将技能目录复制到 Windsurf skills 目录
+2. 确保 SKILL.md 文件格式正确
+3. 在 Windsurf 中激活技能
+
+**示例结构：**
+```
+.windsurf/
+└── skills/
+    └── course-designer/
+        ├── SKILL.md
+        ├── scripts/          # 如果原技能有脚本
+        └── templates/        # 如果原技能有模板
+```
+
+### 8. CodeBuddy（需要适配）
+
+> **注意：** 以下适配方案为理论性建议，需要根据 CodeBuddy 平台的实际功能进行验证。建议先查阅 CodeBuddy 的官方文档了解其支持的插件或 workflow 格式。
+
+CodeBuddy 如果支持 workflows 或 tips 插件，可以这样适配：
+
+#### 适配步骤
+
+1. **创建插件包**
+   - 将技能打包为 CodeBuddy 支持的格式
+   - 包含 manifest 文件和技能内容
+
+2. **转换为 Workflow 格式**
+   - 将技能的工作流程转换为 CodeBuddy 的 workflow 格式
+   - 定义输入、输出和步骤
+
+**示例结构：**
+```
+codebuddy-plugin/
+├── manifest.json
+├── workflows/
+│   ├── course-design.json
+│   └── code-generation.json
+└── skills/
+    └── course-designer/
+        └── SKILL.md
+```
+
+## 通用适配方案
+
+### 方案一：作为文档/上下文使用
+
+大多数 AI 平台都支持读取项目中的文档文件，可以将 skills 作为上下文文档使用。
+
+**步骤：**
+1. 将技能目录复制到项目根目录
+2. 在平台设置中配置读取这些文件
+3. AI 会自动参考这些文档内容
+
+**优点：**
+- 简单直接
+- 不需要特殊配置
+- 跨平台兼容性好
+
+**缺点：**
+- 不会自动触发
+- 需要用户明确引用
+
+### 方案二：转换为自定义指令
+
+将技能内容转换为平台的自定义指令格式。
+
+**步骤：**
+1. 提取 `SKILL.md` 的核心指令部分
+2. 转换为目标平台的自定义指令格式
+3. 在平台设置中配置
+
+**示例（通用格式）：**
+```markdown
+# Custom Instruction: Course Designer
+
+When the user asks about course design:
+- Analyze requirements
+- Design course structure
+- Create learning objectives
+- Plan assessments
+
+[详细指令内容...]
+```
+
+### 方案三：创建适配层
+
+为不同平台创建适配层，将 Agent Skills 标准转换为平台特定格式。
+
+**项目结构：**
+```
+adapters/
+├── cursor/
+│   └── convert_to_cursor.py
+├── trae/
+│   └── convert_to_trae.py
+├── qoder/
+│   └── convert_to_qoder.py
+├── codebuddy/
+│   └── convert_to_codebuddy.py
+└── windsurf/
+    └── convert_to_windsurf.py
+```
+
+**转换脚本示例：**
+```python
+# adapters/cursor/convert_to_cursor.py
+def convert_skill_to_cursor(skill_path):
+    """
+    Convert Agent Skill to Cursor custom instruction format
+    """
+    with open(f"{skill_path}/SKILL.md", "r") as f:
+        content = f.read()
+    
+    # 提取 frontmatter
+    frontmatter = extract_frontmatter(content)
+    
+    # 转换为 Cursor 格式
+    cursor_rule = f"""
+# {frontmatter['name']}
+
+{frontmatter['description']}
+
+{content}
+"""
+    return cursor_rule
+```
+
+## 技能结构说明
+
+每个技能包含以下结构，了解这些有助于适配：
+
+```
+skill-name/
+├── SKILL.md              # 核心技能定义（必需）
+├── scripts/              # 可执行脚本（可选）
+│   └── script.py
+├── references/           # 参考文档（可选）
+│   └── reference.md
+└── assets/               # 资源文件（可选）
+    └── template.html
+```
+
+### SKILL.md 结构
+
+```markdown
+---
+name: skill-name
+description: Skill description
+---
+
+# Skill Title
+
+## Overview
+...
+
+## Usage
+...
+
+## Examples
+...
+```
+
+**适配要点：**
+- Frontmatter 中的 `name` 和 `description` 是关键信息
+- Markdown 内容可以直接作为指令使用
+- 脚本和资源需要根据平台能力调整
+
+## 平台特定建议
+
+### Cursor
+
+**推荐方式：**
+1. 使用 `.cursorrules` 文件
+2. 将常用技能添加到项目根目录
+3. 使用 Cursor 的 Composer 功能
+
+**示例 `.cursorrules`：**
+```markdown
+# Teaching AI Skills
+
+When working with course design, use the course-designer skill.
+When generating code, use the code-generator skill.
+
+[技能内容...]
+```
+
+### Trae
+
+**推荐方式：**
+1. 检查 Trae 的插件系统文档
+2. 创建符合 Trae 格式的插件 manifest
+3. 将技能内容作为插件资源
+
+### Qoder
+
+**推荐方式：**
+1. 将技能转换为 Qoder agent 模块
+2. 创建 agent 配置文件（JSON/YAML）
+3. 将技能指令适配为 agent 工作流
+4. 在 Qoder 中注册 agent 并配置权限
+
+**参考资源：**
+- [Qoder 官网](https://qoder.com/)
+- Qoder agent 配置文档（请查阅 Qoder 官方文档）
+
+### Windsurf
+
+**推荐方式：**
+1. 将技能目录复制到 `.windsurf/skills/` 或 `~/.windsurf/skills/`
+2. Windsurf 使用与 Agent Skills 相同的格式，无需转换
+3. 确保所有资源文件（scripts、templates 等）都被复制
+
+**参考资源：**
+- [Windsurf 官网](https://windsurf.com/)
+- [Windsurf Cascade Skills 文档](https://docs.windsurf.com/windsurf/cascade/skills)
+
+### CodeBuddy
+
+**推荐方式：**
+1. 创建 workflow 定义文件
+2. 将技能转换为 step-by-step 工作流
+3. 打包为 CodeBuddy 插件格式
+
+## 最佳实践
+
+### 1. 保持技能独立性
+
+确保每个技能都是自包含的，不依赖特定平台特性。
+
+### 2. 使用相对路径
+
+在技能中使用相对路径引用资源，便于跨平台使用。
+
+### 3. 提供平台适配文档
+
+为每个技能创建平台特定的使用说明。
+
+### 4. 测试兼容性
+
+在不同平台上测试技能的功能和兼容性。
+
+### 5. 创建转换工具
+
+开发自动化工具将技能转换为不同平台格式。
+
+## 转换工具示例
+
+> **注意：** 以下转换工具示例为概念性代码，展示了基本的转换思路。实际使用时需要根据目标平台的具体 API 和格式要求进行调整和测试。
+
+### Python 转换脚本
+
+```python
+#!/usr/bin/env python3
+"""
+Convert Agent Skills to different platform formats
+"""
+import os
+import json
+import yaml
+from pathlib import Path
+
+def convert_to_cursor(skill_path, output_path):
+    """Convert skill to Cursor format"""
+    skill_file = Path(skill_path) / "SKILL.md"
+    with open(skill_file, "r") as f:
+        content = f.read()
+    
+    # Extract frontmatter
+    frontmatter_end = content.find("---", 3)
+    frontmatter = yaml.safe_load(content[3:frontmatter_end])
+    body = content[frontmatter_end + 3:].strip()
+    
+    # Create Cursor rule
+    cursor_rule = f"""# {frontmatter['name']}
+
+{frontmatter['description']}
+
+{body}
+"""
+    
+    with open(output_path, "w") as f:
+        f.write(cursor_rule)
+    
+    print(f"Converted to Cursor format: {output_path}")
+
+def convert_to_platform_manifest(skill_path, platform):
+    """Convert skill to platform-specific manifest"""
+    skill_file = Path(skill_path) / "SKILL.md"
+    with open(skill_file, "r") as f:
+        content = f.read()
+    
+    frontmatter_end = content.find("---", 3)
+    frontmatter = yaml.safe_load(content[3:frontmatter_end])
+    
+    manifest = {
+        "name": frontmatter['name'],
+        "description": frontmatter['description'],
+        "version": "1.0.0",
+        "platform": platform,
+        "skill_file": "SKILL.md"
+    }
+    
+    manifest_path = Path(skill_path) / f"{platform}-manifest.json"
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f, indent=2)
+    
+    print(f"Created manifest: {manifest_path}")
+
+if __name__ == "__main__":
+    # Example usage
+    skill_path = "skills/course-designer"
+    convert_to_cursor(skill_path, ".cursor/rules/course-designer.md")
+    convert_to_platform_manifest(skill_path, "trae")
+```
+
+## 常见问题
+
+### Q: 技能中的脚本在其他平台能运行吗？
+
+A: 取决于平台是否支持执行脚本。如果不支持，需要：
+- 将脚本逻辑转换为平台支持的语言
+- 或者将脚本功能描述为指令，让 AI 生成代码
+
+### Q: 如何确保技能在不同平台上行为一致？
+
+A: 
+- 使用平台无关的指令描述
+- 避免依赖特定平台特性
+- 在多个平台上测试
+
+### Q: 技能的资源文件如何处理？
+
+A: 
+- 使用相对路径
+- 确保资源文件随技能一起复制
+- 在平台配置中设置正确的资源路径
+
+### Q: 如何让技能自动触发？
+
+A: 
+- 在支持自动触发的平台（如 Claude Code），技能会自动触发
+- 在不支持的平台，需要用户明确引用或转换为命令/按钮
+
+## 贡献适配方案
+
+如果你为某个平台创建了适配方案，欢迎贡献：
+
+1. Fork 本仓库
+2. 在 `adapters/` 目录下创建平台适配代码
+3. **提供实际测试验证**：说明在哪个平台版本上测试过，测试结果如何
+4. 更新本文档，标注已验证的平台和方法
+5. 提交 Pull Request
+
+### 已验证的平台
+
+目前以下平台的适配方法已经过实际验证：
+
+- ✅ **Claude Code** - 原生支持，已验证
+- ✅ **Claude.ai** - 原生支持，已验证
+- ✅ **Claude API** - 原生支持，已验证
+
+以下平台的方法需要社区验证：
+
+- ⚠️ **Cursor** - 需要验证（基于 Cursor 的一般特性提出）
+- ⚠️ **Trae** - 需要验证（理论性建议）
+- ⚠️ **Qoder** - 需要验证（基于 agentic platform 特性提出）
+- ⚠️ **Windsurf** - 需要验证（使用相同格式，转换简单）
+- ⚠️ **CodeBuddy** - 需要验证（理论性建议）
+
+如果你验证了某个平台的适配方法，请在 Pull Request 中说明：
+- 测试的平台版本
+- 测试环境
+- 测试结果
+- 遇到的问题和解决方案
+
+### 已验证的平台
+
+目前以下平台的适配方法已经过实际验证：
+
+- ✅ **Claude Code** - 原生支持，已验证
+- ✅ **Claude.ai** - 原生支持，已验证
+- ✅ **Claude API** - 原生支持，已验证
+
+以下平台的方法需要社区验证：
+
+- ⚠️ **Cursor** - 需要验证
+- ⚠️ **Trae** - 需要验证
+- ⚠️ **Qoder** - 需要验证
+- ⚠️ **CodeBuddy** - 需要验证
+
+如果你验证了某个平台的适配方法，请在 Pull Request 中说明测试环境和结果。
+
+## 参考资源
+
+- [Agent Skills 规范](https://agentskills.io/)
+- [Claude Skills 文档](https://support.claude.com/en/articles/12512176-what-are-skills)
+- [Cursor 自定义指令文档](https://docs.cursor.com/)
+- [Qoder 官网](https://qoder.com/)
+- [Windsurf 官网](https://windsurf.com/)
+- [Windsurf Cascade Skills 文档](https://docs.windsurf.com/windsurf/cascade/skills)
+- 各平台官方文档
+
+## 联系方式
+
+如有问题或需要帮助，请通过 GitHub Issues 联系我们。

QUICKSTART.md

@@ -0,0 +1,229 @@
+# 快速开始指南
+
+本指南将帮助您快速搭建自己的 Skills Marketplace。
+
+## 5 分钟快速搭建
+
+### 步骤 1: 准备 GitHub 仓库
+
+1. 在 GitHub 上创建一个新的公开仓库（例如：`your-username/skills`）
+2. 克隆仓库到本地：
+
+```bash
+git clone https://github.com/your-username/skills.git
+cd skills
+```
+
+### 步骤 2: 复制文件结构
+
+将本项目的以下文件复制到您的仓库：
+
+```
+.claude-plugin/
+└── marketplace.json
+skills/
+├── course-designer/
+│   └── SKILL.md
+├── learning-assessor/
+│   └── SKILL.md
+└── ...
+README.md
+```
+
+### 步骤 3: 修改配置
+
+编辑 `.claude-plugin/marketplace.json`，修改以下内容：
+
+```json
+{
+  "name": "your-marketplace-name",  // 修改为您的 marketplace 名称
+  "owner": {
+    "name": "Your Name",            // 修改为您的名称
+    "email": "your@email.com"       // 修改为您的邮箱
+  },
+  "metadata": {
+    "description": "您的 marketplace 描述",
+    "version": "1.0.0"
+  },
+  "plugins": [
+    // 根据您的 skills 修改插件配置
+  ]
+}
+```
+
+### 步骤 4: 提交到 GitHub
+
+```bash
+git add .
+git commit -m "Initial marketplace setup"
+git push origin main
+```
+
+### 步骤 5: 在 Claude Code 中使用
+
+在 Claude Code 中运行：
+
+```
+/plugin marketplace add your-username/skills
+```
+
+然后安装插件：
+
+```
+/plugin install your-plugin-name@your-marketplace-name
+```
+
+## 核心文件说明
+
+### 1. `.claude-plugin/marketplace.json`
+
+这是 marketplace 的核心配置文件，定义了：
+- Marketplace 的名称和元数据
+- 可用的插件列表
+- 每个插件包含的技能
+
+### 2. `skills/*/SKILL.md`
+
+每个技能必须包含一个 `SKILL.md` 文件，格式：
+
+```markdown
+---
+name: skill-name
+description: 技能的简短描述
+---
+
+# 技能名称
+
+技能内容...
+```
+
+### 3. `README.md`
+
+项目的说明文档，帮助用户了解如何使用您的 marketplace。
+
+## 添加新技能
+
+### 1. 创建技能目录
+
+```bash
+mkdir -p skills/my-new-skill
+```
+
+### 2. 创建 SKILL.md
+
+```bash
+cat > skills/my-new-skill/SKILL.md << 'EOF'
+---
+name: my-new-skill
+description: 我的新技能描述
+---
+
+# 我的新技能
+
+技能内容...
+EOF
+```
+
+### 3. 更新 marketplace.json
+
+在 `plugins` 数组中添加新技能：
+
+```json
+{
+  "name": "my-plugin",
+  "skills": [
+    "./skills/my-new-skill"
+  ]
+}
+```
+
+### 4. 提交更改
+
+```bash
+git add skills/my-new-skill .claude-plugin/marketplace.json.back
+git commit -m "Add new skill: my-new-skill"
+git push
+```
+
+## 验证安装
+
+### 检查 marketplace.json
+
+确保 JSON 格式正确：
+
+```bash
+cat .claude-plugin/marketplace.json.back | python -m json.tool
+```
+
+### 检查技能文件
+
+确保每个技能都有 `SKILL.md` 文件：
+
+```bash
+find skills -name "SKILL.md" -type f
+```
+
+### 测试 GitHub 访问
+
+确保文件可以通过 GitHub 访问：
+
+```
+https://raw.githubusercontent.com/your-username/skills/main/.claude-plugin/marketplace.json
+```
+
+## 常见问题
+
+### Q: 命令执行后没有反应？
+
+A: 检查以下几点：
+1. 仓库是否为公开仓库（public）
+2. `marketplace.json` 文件路径是否正确
+3. JSON 格式是否正确
+4. 网络连接是否正常
+
+### Q: 如何更新技能？
+
+A: 修改 `SKILL.md` 文件，提交并推送到 GitHub。Claude Code 会自动获取最新版本。
+
+### Q: 可以创建私有 marketplace 吗？
+
+A: 目前 Claude Code 只支持公开的 GitHub 仓库。如果需要私有 marketplace，可能需要其他方案。
+
+### Q: 如何组织多个插件？
+
+A: 在 `marketplace.json` 的 `plugins` 数组中添加多个插件对象，每个插件可以包含不同的技能集合。
+
+## 下一步
+
+- 阅读 [IMPLEMENTATION.md](IMPLEMENTATION.md) 了解详细实现机制
+- 阅读 [README.md](README_anthropic_skills.md) 了解完整使用说明
+- 参考 [agent-skills](https://github.com/anthropics/skills) 获取更多示例
+
+## 示例命令
+
+```bash
+# 注册 marketplace
+/plugin marketplace add your-username/skills
+
+# 查看可用插件
+# 在 Claude Code 界面中选择 "Browse and install plugins"
+
+# 安装插件
+/plugin install teaching-skills@your-marketplace-name
+
+# 使用技能
+# 直接在对话中提及技能即可，例如：
+# "使用课程设计技能帮我设计一门课程"
+```
+
+## 总结
+
+搭建 Skills Marketplace 只需要：
+
+1. ✅ 创建 GitHub 仓库
+2. ✅ 创建 `.claude-plugin/marketplace.json`
+3. ✅ 创建 skills 目录和 `SKILL.md` 文件
+4. ✅ 提交到 GitHub
+5. ✅ 在 Claude Code 中使用
+
+整个过程完全基于 GitHub，无需额外的服务器或 API！

README.md

@@ -0,0 +1,592 @@
+# Teaching AI Skills Marketplace
+
+这是一个免费的技能市场，提供各种实用的 AI 技能集合，可以在 Claude Code 中使用。
+
+> **说明：** 本仓库合并了 Anthropic 的示例技能和 Agent Skills 的技能集合，提供各种实用的 AI 技能，可以在 Claude Code、Claude.ai 和 API 中使用。关于 Agent Skills 标准，请参见 [agentskills.io](http://agentskills.io)。
+
+## 什么是 Skills？
+
+Skills 是由说明、脚本和资源组成的文件夹，Claude 会按需动态加载它们，以提升在特定任务上的表现。Skills 用于以可复用的方式教会 Claude 完成具体工作，例如：按你公司的品牌规范创建文档、用你组织的既定流程分析数据，或自动化个人任务。
+
+### 更多信息
+
+- [什么是技能？](https://support.claude.com/en/articles/12512176-what-are-skills)
+- [在 Claude 中使用技能](https://support.claude.com/en/articles/12512180-using-skills-in-claude)
+- [如何创建自定义技能](https://support.claude.com/en/articles/12512198-creating-custom-skills)
+- [用 Agent Skills 为现实世界装备智能体](https://anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills)
+- [Agent Skills 规范](https://agentskills.io/)
+
+## 关于本仓库
+
+本仓库包含一组技能，用于展示 Claude 的技能系统能够实现哪些能力。这些技能覆盖从创意应用（艺术、音乐、设计）到技术任务（测试 Web 应用、生成 MCP 服务器）再到企业工作流（沟通、品牌等），以及教学与教育场景。
+
+每个技能都自包含在单独的文件夹中，并包含一个 `SKILL.md` 文件，里面有 Claude 使用的说明和元数据。你可以浏览这些技能来获取灵感，或理解不同的模式与实现方式。
+
+本仓库中的许多技能是开源的（Apache 2.0）。我们还在 [`skills/docx`](skills/docx)、[`skills/pdf`](skills/pdf)、[`skills/pptx`](skills/pptx) 和 [`skills/xlsx`](skills/xlsx) 子目录中包含了用于支撑 [Claude 文档能力](https://www.anthropic.com/news/create-files) 的文档创建与编辑技能。这些技能是"可查看源码"的（source-available），但并非开源；我们希望将其作为更复杂技能的参考示例，因为它们已在生产级 AI 应用中实际使用。
+
+### 免责声明
+
+**这些技能仅用于演示与教育用途。** 虽然其中部分能力可能在 Claude 中可用，但你从 Claude 获得的实现与行为可能与这些技能所展示的不同。这些技能旨在展示模式与可能性。在依赖它们处理关键任务之前，请务必在你自己的环境中充分测试。
+
+## 如何使用
+
+### 在 Claude Code 中使用
+
+#### 1. 注册 Marketplace
+
+在 Claude Code 中运行以下命令，将本仓库注册为 Claude Code 的插件市场：
+
+```
+/plugin marketplace add teaching-ai/skills
+```
+
+> **注意**: 请将 `teaching-ai/skills` 替换为您的实际 GitHub 仓库路径（格式：`用户名/仓库名`）
+
+#### 2. 安装插件
+
+安装插件有两种方式：
+
+**方式一：通过界面安装**
+
+1. 选择 `Browse and install plugins`
+2. 选择 `teaching-ai-skills`
+3. 选择要安装的插件（见下方可用插件列表）
+4. 选择 `Install now`
+
+**方式二：通过命令安装**
+
+直接使用命令安装插件：
+
+```
+/plugin install teaching-skills@teaching-ai-skills
+/plugin install document-skills@teaching-ai-skills
+/plugin install markdown-skills@teaching-ai-skills
+/plugin install development-skills@teaching-ai-skills
+/plugin install design-skills@teaching-ai-skills
+/plugin install social-skills@teaching-ai-skills
+/plugin install utility-skills@teaching-ai-skills
+```
+
+#### 3. 使用技能
+
+安装插件后，您只需提到该技能即可使用。Claude 会根据技能描述自动判断何时使用该技能。
+
+### 在 Claude.ai 中使用
+
+这些示例技能在 Claude.ai 的付费套餐中已默认可用。
+
+如需使用本仓库中的任意技能或上传自定义技能，请参考 [在 Claude 中使用技能](https://support.claude.com/en/articles/12512180-using-skills-in-claude#h_a4222fa77b) 的说明。
+
+### 在 Claude API 中使用
+
+你可以通过 Claude API 使用 Anthropic 预置的技能并上传自定义技能。详情参见 [Skills API Quickstart](https://docs.claude.com/en/api/skills-guide#creating-a-skill)。
+
+### 在其他平台使用
+
+这些 skills 也可以在其他 AI 平台使用，如 Cursor、Trae、Qoder、CodeBuddy 等。
+
+**详细说明：**
+- [跨平台使用指南](PLATFORM_GUIDE.md) - 完整的平台适配说明
+- [平台适配器工具](adapters/README.md) - 自动转换工具和示例
+- [适配器示例](adapters/EXAMPLES.md) - 转换后的示例文件
+
+**快速转换：**
+```bash
+cd adapters
+python convert_all.py ../skills ../adapters-output
+```
+
+## 可用插件和技能
+
+本仓库的技能按功能分为 7 个插件类别，共包含 23 个技能：
+
+### 1. teaching-skills（教学技能集合）
+
+教学与教育相关技能集合，包括课程设计、学习评估、教学资源生成等。
+
+#### course-designer（课程设计技能）
+
+帮助设计和规划课程内容，包括课程大纲、学习目标、教学计划和评估方案。
+
+**使用示例：**
+- "使用课程设计技能帮我设计一门 Python 编程课程"
+- "设计一个为期 8 周的机器学习入门课程"
+- "创建一个关于 Web 开发的课程大纲"
+
+#### learning-assessor（学习评估技能）
+
+帮助创建学习评估工具，包括测验题目、评估标准、评分 rubric 和学习分析。
+
+**使用示例：**
+- "使用学习评估技能为我的课程创建一套测验题目"
+- "设计一个评估学生学习效果的 rubric"
+- "生成一份学习分析报告"
+
+#### teaching-resource-generator（教学资源生成技能）
+
+帮助生成各种教学资源，包括课件、练习题、教学案例、学习指南等。
+
+**使用示例：**
+- "使用教学资源生成技能为我的课程创建一套课件"
+- "生成一些关于数据结构的练习题"
+- "创建一个教学案例用于讲解设计模式"
+
+### 2. document-skills（文档处理技能集合）
+
+文档处理技能集合，支持 Excel、Word、PowerPoint、PDF 等办公文档的创建、编辑和处理。
+
+#### docx（Word 文档处理）
+
+创建、编辑和处理 Microsoft Word 文档。
+
+**使用示例：**
+- "Use the DOCX skill to create a new Word document"
+- "Extract text from this Word document"
+- "Format this document with headings and styles"
+
+#### pptx（PowerPoint 演示文稿处理）
+
+创建、编辑和处理 Microsoft PowerPoint 演示文稿。
+
+**使用示例：**
+- "Use the PPTX skill to create a presentation"
+- "Add slides to this PowerPoint file"
+- "Apply a theme to this presentation"
+
+#### pdf（PDF 文档处理）
+
+处理 PDF 文档，包括提取文本、填写表单、合并拆分等。
+
+**使用示例：**
+- "Use the PDF skill to extract the form fields from `path/to/some-file.pdf`"
+- "Fill out this PDF form"
+- "Merge multiple PDF files"
+
+#### xlsx（Excel 表格处理）
+
+创建、编辑和处理 Microsoft Excel 电子表格。
+
+**使用示例：**
+- "Use the XLSX skill to create a spreadsheet"
+- "Analyze data in this Excel file"
+- "Generate charts from this spreadsheet"
+
+#### doc-coauthoring（文档协作）
+
+支持多人协作编辑文档的功能。
+
+**使用示例：**
+- "Use the doc-coauthoring skill to prepare this document for collaboration"
+- "Add comments and suggestions to this document"
+
+### 3. markdown-skills（Markdown 技能集合）
+
+Markdown 相关技能集合，包括 Mermaid 图表绘制等。
+
+#### mermaid（Mermaid 图表绘制）
+
+创建各种类型的 Mermaid 图表，包括流程图、时序图、类图、状态图、甘特图等。
+
+**使用示例：**
+- "使用 Mermaid 创建一个流程图"
+- "绘制一个系统架构的 C4 图"
+- "生成一个项目时间线的甘特图"
+- "创建一个用户旅程图"
+
+**支持的图表类型：**
+- 流程图（flowchart）
+- 时序图（sequence diagram）
+- 类图（class diagram）
+- 状态图（state diagram）
+- 实体关系图（ER diagram）
+- 用户旅程图（user journey）
+- 甘特图（Gantt chart）
+- 饼图（pie chart）
+- 象限图（quadrant chart）
+- Git 图（Git graph）
+- C4 架构图（C4 diagram）
+- 思维导图（mindmap）
+- 时间线图（timeline）
+- 桑基图（Sankey diagram）
+- 以及其他多种图表类型
+
+### 4. development-skills（开发技能集合）
+
+开发技能集合，包括代码生成、测试编写、文档构建、MCP 构建器、Web 开发、前端设计等。
+
+#### code-generator（代码生成技能）
+
+帮助生成高质量的代码，支持多种编程语言，遵循最佳实践和设计模式。
+
+**使用示例：**
+- "使用代码生成技能生成一个用户认证的 Python 类"
+- "创建一个 RESTful API 的 Node.js 实现"
+- "生成一个符合 SOLID 原则的 Java 类"
+
+#### test-writer（测试编写技能）
+
+帮助编写单元测试、集成测试和端到端测试。
+
+**使用示例：**
+- "为这个函数编写单元测试"
+- "创建集成测试来验证 API 接口"
+- "生成端到端测试用例"
+
+#### documentation-builder（文档构建技能）
+
+帮助生成技术文档，包括 API 文档、用户手册、开发指南、README 等。
+
+**使用示例：**
+- "使用文档构建技能为我的项目生成 API 文档"
+- "创建一个用户使用手册"
+- "编写开发环境搭建指南"
+
+#### mcp-builder（MCP 构建器）
+
+帮助创建和配置 Model Context Protocol (MCP) 服务器。
+
+**使用示例：**
+- "使用 MCP 构建器创建一个新的 MCP 服务器"
+- "配置 MCP 服务器的工具和资源"
+- "生成 MCP 服务器的代码模板"
+
+#### webapp-testing（Web 应用测试）
+
+帮助测试 Web 应用程序，包括功能测试、性能测试等。
+
+**使用示例：**
+- "测试这个 Web 应用的功能"
+- "检查这个网站的响应时间"
+- "验证这个应用的跨浏览器兼容性"
+
+#### frontend-design（前端设计）
+
+创建高质量的前端界面，避免通用的 AI 美学，生成具有独特设计感的代码。
+
+**使用示例：**
+- "使用前端设计技能创建一个登录页面"
+- "设计一个现代化的仪表板界面"
+- "创建一个响应式的产品展示页面"
+
+#### web-artifacts-builder（Web 工件构建器）
+
+使用现代前端技术（React、Tailwind CSS、shadcn/ui）创建复杂的多组件 HTML 工件。
+
+**使用示例：**
+- "使用 Web 工件构建器创建一个交互式数据可视化工具"
+- "构建一个带有状态管理的单页应用"
+- "创建一个使用 shadcn/ui 组件的复杂界面"
+
+#### theme-factory（主题工厂）
+
+为工件应用主题样式，包括 10 种预设主题，可以应用到幻灯片、文档、报告、HTML 落地页等。
+
+**使用示例：**
+- "为这个演示文稿应用 Ocean Depths 主题"
+- "使用 Modern Minimalist 主题样式化这个文档"
+- "为这个网页应用 Golden Hour 主题"
+
+### 5. design-skills（设计技能集合）
+
+设计与创意技能集合，包括算法艺术、品牌指南、画布设计等。
+
+#### algorithmic-art（算法艺术）
+
+使用 p5.js 创建算法艺术，支持种子随机数和交互式参数探索。
+
+**使用示例：**
+- "使用算法艺术技能创建一个生成式艺术作品"
+- "生成一个基于粒子系统的可视化"
+- "创建一个流动场效果的艺术作品"
+
+#### brand-guidelines（品牌指南）
+
+应用 Anthropic 官方品牌颜色和排版到任何工件。
+
+**使用示例：**
+- "使用品牌指南技能应用品牌样式到这个文档"
+- "为这个演示文稿应用品牌颜色"
+- "使用品牌字体格式化这个文档"
+
+#### canvas-design（画布设计）
+
+在 HTML Canvas 上创建高质量的设计和可视化。
+
+**使用示例：**
+- "使用画布设计技能创建一个数据可视化图表"
+- "在 Canvas 上绘制一个交互式图形"
+- "创建一个 Canvas 动画效果"
+
+### 6. social-skills（社交技能集合）
+
+社交与协作技能集合，包括内部沟通、Slack GIF 创建等。
+
+#### internal-comms（内部沟通）
+
+帮助编写各种内部沟通文档，包括状态报告、领导更新、3P 更新、公司通讯、FAQ 等。
+
+**使用示例：**
+- "使用内部沟通技能编写一份项目状态报告"
+- "创建一个公司通讯稿"
+- "编写一份 FAQ 文档"
+
+#### slack-gif-creator（Slack GIF 创建器）
+
+创建用于 Slack 的 GIF 动图。
+
+**使用示例：**
+- "使用 Slack GIF 创建器创建一个欢迎动画"
+- "生成一个用于 Slack 消息的 GIF"
+- "创建一个通知动画 GIF"
+
+### 7. utility-skills（工具技能集合）
+
+工具与实用技能集合，包括技能创建器等。
+
+#### skill-creator（技能创建器）
+
+指导如何创建有效的技能，扩展 Claude 的能力。
+
+**使用示例：**
+- "使用技能创建器帮助我创建一个新技能"
+- "如何设计一个技能的结构"
+- "创建一个技能的最佳实践是什么"
+
+## 项目结构
+
+```
+.
+├── .claude-plugin/
+│   └── marketplace.json          # Marketplace 配置文件
+├── skills/                        # Skills 目录
+│   ├── teaching-skills/          # 教学技能
+│   │   ├── course-designer/
+│   │   ├── learning-assessor/
+│   │   └── teaching-resource-generator/
+│   ├── document-skills/          # 文档处理技能
+│   │   ├── docx/
+│   │   ├── pptx/
+│   │   ├── pdf/
+│   │   ├── xlsx/
+│   │   └── doc-coauthoring/
+│   ├── markdown-skills/          # Markdown 技能
+│   │   └── mermaid/
+│   ├── development-skills/       # 开发技能
+│   │   ├── code-generator/
+│   │   ├── test-writer/
+│   │   ├── documentation-builder/
+│   │   ├── mcp-builder/
+│   │   ├── webapp-testing/
+│   │   ├── frontend-design/
+│   │   ├── web-artifacts-builder/
+│   │   └── theme-factory/
+│   ├── design-skills/            # 设计技能
+│   │   ├── algorithmic-art/
+│   │   ├── brand-guidelines/
+│   │   └── canvas-design/
+│   ├── social-skills/            # 社交技能
+│   │   ├── internal-comms/
+│   │   └── slack-gif-creator/
+│   └── utility-skills/           # 工具技能
+│       └── skill-creator/
+├── spec/                          # Agent Skills 规范
+├── template/                      # 技能模板
+└── README.md                      # 本文件
+```
+
+## 如何创建新技能
+
+### 创建一个基础技能
+
+创建技能非常简单——只需要一个包含带 YAML frontmatter 的 `SKILL.md` 文件的文件夹即可。你可以使用本仓库中的 **template-skill** 作为起点：
+
+```markdown
+---
+name: my-skill-name
+description: A clear description of what this skill does and when to use it
+---
+
+# My Skill Name
+
+[Add your instructions here that Claude will follow when this skill is active]
+
+## Examples
+- Example usage 1
+- Example usage 2
+
+## Guidelines
+- Guideline 1
+- Guideline 2
+```
+
+frontmatter 只需要两个字段：
+- `name` - 你的技能的唯一标识符（小写，空格用连字符）
+- `description` - 对该技能做什么、何时使用的完整描述
+
+下面的 Markdown 内容包含了该技能激活时 Claude 要遵循的说明、示例和指南。更多细节请参见 [如何创建自定义技能](https://support.claude.com/en/articles/12512198-creating-custom-skills)。
+
+### 技能结构
+
+每个技能包含：
+- `SKILL.md` - 给智能体的说明（必需）
+- `scripts/` - 自动化辅助脚本（可选）
+- `references/` - 支撑文档（可选）
+- `assets/` - 资源文件（可选）
+
+### 添加新技能的步骤
+
+#### 1. 创建 Skill 目录
+
+在 `skills/` 目录下创建新的技能目录：
+
+```bash
+mkdir -p skills/your-skill-name
+```
+
+#### 2. 创建 SKILL.md 文件
+
+每个技能必须包含一个 `SKILL.md` 文件，格式如上所示。
+
+#### 3. 更新 marketplace.json
+
+在 `.claude-plugin/marketplace.json` 中添加新技能到相应的插件中：
+
+```json
+{
+  "plugins": [
+    {
+      "name": "your-plugin-name",
+      "description": "插件描述",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/your-skill-name"
+      ]
+    }
+  ]
+}
+```
+
+#### 4. 提交到 GitHub
+
+将更改提交并推送到 GitHub 仓库：
+
+```bash
+git add .
+git commit -m "Add new skill: your-skill-name"
+git push
+```
+
+## Marketplace 配置文件说明
+
+`.claude-plugin/marketplace.json` 文件定义了 marketplace 的元数据和可用的插件：
+
+```json
+{
+  "name": "marketplace-name",        // Marketplace 名称
+  "owner": {                         // 所有者信息
+    "name": "Owner Name",
+    "email": "owner@example.com"
+  },
+  "metadata": {                      // 元数据
+    "description": "Marketplace 描述",
+    "version": "1.0.0"
+  },
+  "plugins": [                       // 插件列表
+    {
+      "name": "plugin-name",         // 插件名称
+      "description": "插件描述",
+      "source": "./",                // 源代码路径
+      "strict": false,               // 是否严格模式
+      "skills": [                    // 技能列表
+        "./skills/skill1",
+        "./skills/skill2"
+      ]
+    }
+  ]
+}
+```
+
+## 工作原理
+
+1. **Marketplace 注册**: 当您运行 `/plugin marketplace add teaching-ai/skills` 时，Claude Code 会：
+   - 从 GitHub 仓库获取 `.claude-plugin/marketplace.json` 文件
+   - 解析 marketplace 配置
+   - 将 marketplace 添加到可用列表
+
+2. **插件安装**: 当您安装插件时，Claude Code 会：
+   - 下载插件中定义的所有 skills
+   - 将 skills 存储到本地
+   - 使 skills 可用于 Claude
+
+3. **技能使用**: 当您使用技能时，Claude 会：
+   - 根据技能描述判断是否使用该技能
+   - 加载技能的 `SKILL.md` 文件
+   - 按照技能说明执行任务
+
+## 最佳实践
+
+### Skill 设计
+
+- **清晰的描述**: `description` 字段应该清楚地说明何时使用该技能
+- **简洁的内容**: 保持 `SKILL.md` 简洁，避免不必要的冗长（建议控制在 500 行以内）
+- **结构化组织**: 使用清晰的章节和结构
+- **实用示例**: 提供实际可用的示例
+- **渐进式披露**: 将详细参考资料放在单独文件中，按需加载
+
+### Marketplace 组织
+
+- **逻辑分组**: 将相关技能组织到同一个插件中
+- **清晰的命名**: 使用清晰、描述性的名称
+- **版本管理**: 在 `metadata` 中维护版本号
+
+## 许可证
+
+本仓库中的许多技能采用 Apache 2.0 许可证。文档处理技能（docx、pdf、pptx、xlsx）是"可查看源码"的（source-available），但并非开源。详见各技能目录中的 LICENSE 文件。
+
+## 贡献
+
+欢迎贡献新的技能！请遵循以下步骤：
+
+1. Fork 本仓库
+2. 创建新的技能或改进现有技能
+3. 提交 Pull Request
+
+## 合作伙伴技能
+
+技能是教会 Claude 更好使用特定软件的一种好方式。我们看到来自合作伙伴的优秀示例技能时，也可能会在这里进行展示：
+
+- **Notion** - [Notion Skills for Claude](https://www.notion.so/notiondevs/Notion-Skills-for-Claude-28da4445d27180c7af1df7d8615723d0)
+
+## 跨平台适配
+
+本仓库提供了将 skills 适配到其他平台的工具和示例：
+
+- **适配器工具**: `adapters/` 目录包含转换脚本
+- **平台支持**: Cursor、Trae、Qoder、CodeBuddy
+- **示例文件**: `adapters/examples/` 包含转换后的示例
+
+详细说明请参考：
+- [跨平台使用指南](PLATFORM_GUIDE.md)
+- [适配器工具文档](adaptersEADME.md)
+- [适配器示例](adaptersXAMPLES.md)
+
+**快速转换：**
+```bash
+cd adapters
+python convert_all.py ../skills ../adapters-output
+```
+
+## 参考资源
+
+- [Agent Skills 规范](https://agentskills.io/)
+- [Claude Skills 文档](https://support.claude.com/en/articles/12512176-what-are-skills)
+- [在 Claude 中使用技能](https://support.claude.com/en/articles/12512180-using-skills-in-claude)
+- [如何创建自定义技能](https://support.claude.com/en/articles/12512198-creating-custom-skills)
+- [用 Agent Skills 为现实世界装备智能体](https://anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills)
+- [Anthropic Skills 示例](https://github.com/anthropics/skills)
+- [Skills API Quickstart](https://docs.claude.com/en/api/skills-guide#creating-a-skill)
+
+## 联系方式
+
+如有问题或建议，请通过 GitHub Issues 联系我们。

README_EN.md

@@ -0,0 +1,562 @@
+# Teaching AI Skills Marketplace
+
+A free skills marketplace providing various practical AI skill collections that can be used in Claude Code.
+
+> **Note:** This repository merges Anthropic's example skills and Agent Skills collections, providing various practical AI skills that can be used in Claude Code, Claude.ai, and the API. For information about the Agent Skills standard, see [agentskills.io](http://agentskills.io).
+
+## What are Skills?
+
+Skills are folders of instructions, scripts, and resources that Claude loads dynamically to improve performance on specialized tasks. Skills teach Claude how to complete specific tasks in a repeatable way, whether that's creating documents with your company's brand guidelines, analyzing data using your organization's specific workflows, or automating personal tasks.
+
+### More Information
+
+- [What are skills?](https://support.claude.com/en/articles/12512176-what-are-skills)
+- [Using skills in Claude](https://support.claude.com/en/articles/12512180-using-skills-in-claude)
+- [How to create custom skills](https://support.claude.com/en/articles/12512198-creating-custom-skills)
+- [Equipping agents for the real world with Agent Skills](https://anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills)
+- [Agent Skills specification](https://agentskills.io/)
+
+## About This Repository
+
+This repository contains skills that demonstrate what's possible with Claude's skills system. These skills range from creative applications (art, music, design) to technical tasks (testing web apps, MCP server generation) to enterprise workflows (communications, branding, etc.), as well as teaching and education scenarios.
+
+Each skill is self-contained in its own folder with a `SKILL.md` file containing the instructions and metadata that Claude uses. You can browse through these skills to get inspiration for your own skills or to understand different patterns and approaches.
+
+Many skills in this repo are open source (Apache 2.0). We've also included the document creation & editing skills that power [Claude's document capabilities](https://www.anthropic.com/news/create-files) under the hood in the [`skills/docx`](skills/docx), [`skills/pdf`](skills/pdf), [`skills/pptx`](skills/pptx), and [`skills/xlsx`](skills/xlsx) subfolders. These are source-available, not open source, but we wanted to share these with developers as a reference for more complex skills that are actively used in a production AI application.
+
+### Disclaimer
+
+**These skills are provided for demonstration and educational purposes only.** While some of these capabilities may be available in Claude, the implementations and behaviors you receive from Claude may differ from what is shown in these skills. These skills are meant to illustrate patterns and possibilities. Always test skills thoroughly in your own environment before relying on them for critical tasks.
+
+## How to Use
+
+### Using in Claude Code
+
+#### 1. Register Marketplace
+
+Run the following command in Claude Code to register this repository as a Claude Code plugin marketplace:
+
+```
+/plugin marketplace add teaching-ai/skills
+```
+
+> **Note**: Replace `teaching-ai/skills` with your actual GitHub repository path (format: `username/repository-name`)
+
+#### 2. Install Plugins
+
+There are two ways to install plugins:
+
+**Method 1: Install via UI**
+
+1. Select `Browse and install plugins`
+2. Select `teaching-ai-skills`
+3. Select the plugin you want to install (see available plugins list below)
+4. Select `Install now`
+
+**Method 2: Install via Command**
+
+Install plugins directly using commands:
+
+```
+/plugin install teaching-skills@teaching-ai-skills
+/plugin install document-skills@teaching-ai-skills
+/plugin install markdown-skills@teaching-ai-skills
+/plugin install development-skills@teaching-ai-skills
+/plugin install design-skills@teaching-ai-skills
+/plugin install social-skills@teaching-ai-skills
+/plugin install utility-skills@teaching-ai-skills
+```
+
+#### 3. Use Skills
+
+After installing plugins, you can use skills by simply mentioning them. Claude will automatically determine when to use a skill based on its description.
+
+### Using in Claude.ai
+
+These example skills are all already available to paid plans in Claude.ai.
+
+To use any skill from this repository or upload custom skills, follow the instructions in [Using skills in Claude](https://support.claude.com/en/articles/12512180-using-skills-in-claude#h_a4222fa77b).
+
+### Using in Claude API
+
+You can use Anthropic's pre-built skills, and upload custom skills, via the Claude API. See the [Skills API Quickstart](https://docs.claude.com/en/api/skills-guide#creating-a-skill) for more.
+
+### Using on Other Platforms
+
+These skills can also be used on other AI platforms such as Cursor, Trae, Qoder, CodeBuddy, etc. For detailed instructions, please refer to the [Cross-Platform Usage Guide](PLATFORM_GUIDE.md).
+
+## Available Plugins and Skills
+
+The skills in this repository are organized into 7 plugin categories, containing a total of 23 skills:
+
+### 1. teaching-skills (Teaching Skills Collection)
+
+Teaching and education-related skills collection, including course design, learning assessment, and teaching resource generation.
+
+#### course-designer (Course Design Skill)
+
+Helps design and plan course content, including course outlines, learning objectives, teaching plans, and assessment schemes.
+
+**Usage Examples:**
+- "Use the course design skill to help me design a Python programming course"
+- "Design an 8-week machine learning introductory course"
+- "Create a course outline for web development"
+
+#### learning-assessor (Learning Assessment Skill)
+
+Helps create learning assessment tools, including quiz questions, assessment criteria, scoring rubrics, and learning analytics.
+
+**Usage Examples:**
+- "Use the learning assessment skill to create a set of quiz questions for my course"
+- "Design a rubric to assess student learning outcomes"
+- "Generate a learning analytics report"
+
+#### teaching-resource-generator (Teaching Resource Generator Skill)
+
+Helps generate various teaching resources, including courseware, exercises, teaching cases, and study guides.
+
+**Usage Examples:**
+- "Use the teaching resource generator skill to create courseware for my course"
+- "Generate some exercises about data structures"
+- "Create a teaching case for explaining design patterns"
+
+### 2. document-skills (Document Processing Skills Collection)
+
+Document processing skills collection, supporting creation, editing, and processing of office documents including Excel, Word, PowerPoint, and PDF.
+
+#### docx (Word Document Processing)
+
+Create, edit, and process Microsoft Word documents.
+
+**Usage Examples:**
+- "Use the DOCX skill to create a new Word document"
+- "Extract text from this Word document"
+- "Format this document with headings and styles"
+
+#### pptx (PowerPoint Presentation Processing)
+
+Create, edit, and process Microsoft PowerPoint presentations.
+
+**Usage Examples:**
+- "Use the PPTX skill to create a presentation"
+- "Add slides to this PowerPoint file"
+- "Apply a theme to this presentation"
+
+#### pdf (PDF Document Processing)
+
+Process PDF documents, including text extraction, form filling, merging, and splitting.
+
+**Usage Examples:**
+- "Use the PDF skill to extract the form fields from `path/to/some-file.pdf`"
+- "Fill out this PDF form"
+- "Merge multiple PDF files"
+
+#### xlsx (Excel Spreadsheet Processing)
+
+Create, edit, and process Microsoft Excel spreadsheets.
+
+**Usage Examples:**
+- "Use the XLSX skill to create a spreadsheet"
+- "Analyze data in this Excel file"
+- "Generate charts from this spreadsheet"
+
+#### doc-coauthoring (Document Co-authoring)
+
+Supports multi-user collaborative document editing.
+
+**Usage Examples:**
+- "Use the doc-coauthoring skill to prepare this document for collaboration"
+- "Add comments and suggestions to this document"
+
+### 3. markdown-skills (Markdown Skills Collection)
+
+Markdown-related skills collection, including Mermaid diagram creation.
+
+#### mermaid (Mermaid Diagram Creation)
+
+Create various types of Mermaid diagrams, including flowcharts, sequence diagrams, class diagrams, state diagrams, Gantt charts, and more.
+
+**Usage Examples:**
+- "Use Mermaid to create a flowchart"
+- "Draw a C4 diagram for system architecture"
+- "Generate a Gantt chart for project timeline"
+- "Create a user journey diagram"
+
+**Supported Diagram Types:**
+- Flowcharts
+- Sequence diagrams
+- Class diagrams
+- State diagrams
+- Entity relationship diagrams (ER diagrams)
+- User journey diagrams
+- Gantt charts
+- Pie charts
+- Quadrant charts
+- Git graphs
+- C4 architecture diagrams
+- Mindmaps
+- Timelines
+- Sankey diagrams
+- And many other diagram types
+
+### 4. development-skills (Development Skills Collection)
+
+Development skills collection, including code generation, test writing, documentation building, MCP builder, web development, frontend design, and more.
+
+#### code-generator (Code Generation Skill)
+
+Helps generate high-quality code, supporting multiple programming languages, following best practices and design patterns.
+
+**Usage Examples:**
+- "Use the code generation skill to generate a user authentication Python class"
+- "Create a RESTful API implementation in Node.js"
+- "Generate a Java class following SOLID principles"
+
+#### test-writer (Test Writing Skill)
+
+Helps write unit tests, integration tests, and end-to-end tests.
+
+**Usage Examples:**
+- "Write unit tests for this function"
+- "Create integration tests to verify API endpoints"
+- "Generate end-to-end test cases"
+
+#### documentation-builder (Documentation Builder Skill)
+
+Helps generate technical documentation, including API documentation, user manuals, development guides, and README files.
+
+**Usage Examples:**
+- "Use the documentation builder skill to generate API documentation for my project"
+- "Create a user manual"
+- "Write a development environment setup guide"
+
+#### mcp-builder (MCP Builder)
+
+Helps create and configure Model Context Protocol (MCP) servers.
+
+**Usage Examples:**
+- "Use the MCP builder to create a new MCP server"
+- "Configure tools and resources for an MCP server"
+- "Generate code templates for an MCP server"
+
+#### webapp-testing (Web Application Testing)
+
+Helps test web applications, including functional testing and performance testing.
+
+**Usage Examples:**
+- "Test the functionality of this web application"
+- "Check the response time of this website"
+- "Verify cross-browser compatibility of this application"
+
+#### frontend-design (Frontend Design)
+
+Create high-quality frontend interfaces, avoiding generic AI aesthetics, generating code with unique design sense.
+
+**Usage Examples:**
+- "Use the frontend design skill to create a login page"
+- "Design a modern dashboard interface"
+- "Create a responsive product showcase page"
+
+#### web-artifacts-builder (Web Artifacts Builder)
+
+Create complex multi-component HTML artifacts using modern frontend technologies (React, Tailwind CSS, shadcn/ui).
+
+**Usage Examples:**
+- "Use the web artifacts builder to create an interactive data visualization tool"
+- "Build a single-page application with state management"
+- "Create a complex interface using shadcn/ui components"
+
+#### theme-factory (Theme Factory)
+
+Apply theme styles to artifacts, including 10 preset themes that can be applied to slides, documents, reports, HTML landing pages, and more.
+
+**Usage Examples:**
+- "Apply the Ocean Depths theme to this presentation"
+- "Style this document with the Modern Minimalist theme"
+- "Apply the Golden Hour theme to this webpage"
+
+### 5. design-skills (Design Skills Collection)
+
+Design and creative skills collection, including algorithmic art, brand guidelines, and canvas design.
+
+#### algorithmic-art (Algorithmic Art)
+
+Create algorithmic art using p5.js with seeded randomness and interactive parameter exploration.
+
+**Usage Examples:**
+- "Use the algorithmic art skill to create a generative artwork"
+- "Generate a visualization based on particle systems"
+- "Create a flow field effect artwork"
+
+#### brand-guidelines (Brand Guidelines)
+
+Apply Anthropic's official brand colors and typography to any artifact.
+
+**Usage Examples:**
+- "Use the brand guidelines skill to apply brand styles to this document"
+- "Apply brand colors to this presentation"
+- "Format this document using brand fonts"
+
+#### canvas-design (Canvas Design)
+
+Create high-quality designs and visualizations on HTML Canvas.
+
+**Usage Examples:**
+- "Use the canvas design skill to create a data visualization chart"
+- "Draw an interactive graphic on Canvas"
+- "Create a Canvas animation effect"
+
+### 6. social-skills (Social Skills Collection)
+
+Social and collaboration skills collection, including internal communications and Slack GIF creation.
+
+#### internal-comms (Internal Communications)
+
+Helps write various internal communication documents, including status reports, leadership updates, 3P updates, company newsletters, FAQs, and more.
+
+**Usage Examples:**
+- "Use the internal communications skill to write a project status report"
+- "Create a company newsletter"
+- "Write an FAQ document"
+
+#### slack-gif-creator (Slack GIF Creator)
+
+Create GIF animations for use in Slack.
+
+**Usage Examples:**
+- "Use the Slack GIF creator to create a welcome animation"
+- "Generate a GIF for Slack messages"
+- "Create a notification animation GIF"
+
+### 7. utility-skills (Utility Skills Collection)
+
+Utility and practical skills collection, including skill creator.
+
+#### skill-creator (Skill Creator)
+
+Guides how to create effective skills to extend Claude's capabilities.
+
+**Usage Examples:**
+- "Use the skill creator to help me create a new skill"
+- "How to design the structure of a skill"
+- "What are the best practices for creating a skill"
+
+## Project Structure
+
+```
+.
+├── .claude-plugin/
+│   └── marketplace.json          # Marketplace configuration file
+├── skills/                        # Skills directory
+│   ├── teaching-skills/          # Teaching skills
+│   │   ├── course-designer/
+│   │   ├── learning-assessor/
+│   │   └── teaching-resource-generator/
+│   ├── document-skills/          # Document processing skills
+│   │   ├── docx/
+│   │   ├── pptx/
+│   │   ├── pdf/
+│   │   ├── xlsx/
+│   │   └── doc-coauthoring/
+│   ├── markdown-skills/          # Markdown skills
+│   │   └── mermaid/
+│   ├── development-skills/       # Development skills
+│   │   ├── code-generator/
+│   │   ├── test-writer/
+│   │   ├── documentation-builder/
+│   │   ├── mcp-builder/
+│   │   ├── webapp-testing/
+│   │   ├── frontend-design/
+│   │   ├── web-artifacts-builder/
+│   │   └── theme-factory/
+│   ├── design-skills/            # Design skills
+│   │   ├── algorithmic-art/
+│   │   ├── brand-guidelines/
+│   │   └── canvas-design/
+│   ├── social-skills/            # Social skills
+│   │   ├── internal-comms/
+│   │   └── slack-gif-creator/
+│   └── utility-skills/           # Utility skills
+│       └── skill-creator/
+├── spec/                          # Agent Skills specification
+├── template/                      # Skill template
+└── README.md                      # This file
+```
+
+## How to Create a New Skill
+
+### Creating a Basic Skill
+
+Skills are simple to create - just a folder with a `SKILL.md` file containing YAML frontmatter and instructions. You can use the **template-skill** in this repository as a starting point:
+
+```markdown
+---
+name: my-skill-name
+description: A clear description of what this skill does and when to use it
+---
+
+# My Skill Name
+
+[Add your instructions here that Claude will follow when this skill is active]
+
+## Examples
+- Example usage 1
+- Example usage 2
+
+## Guidelines
+- Guideline 1
+- Guideline 2
+```
+
+The frontmatter requires only two fields:
+- `name` - A unique identifier for your skill (lowercase, hyphens for spaces)
+- `description` - A complete description of what the skill does and when to use it
+
+The markdown content below contains the instructions, examples, and guidelines that Claude will follow. For more details, see [How to create custom skills](https://support.claude.com/en/articles/12512198-creating-custom-skills).
+
+### Skill Structure
+
+Each skill contains:
+- `SKILL.md` - Instructions for the agent (required)
+- `scripts/` - Helper scripts for automation (optional)
+- `references/` - Supporting documentation (optional)
+- `assets/` - Resource files (optional)
+
+### Steps to Add a New Skill
+
+#### 1. Create Skill Directory
+
+Create a new skill directory under the `skills/` directory:
+
+```bash
+mkdir -p skills/your-skill-name
+```
+
+#### 2. Create SKILL.md File
+
+Each skill must contain a `SKILL.md` file with the format shown above.
+
+#### 3. Update marketplace.json
+
+Add the new skill to the appropriate plugin in `.claude-plugin/marketplace.json`:
+
+```json
+{
+  "plugins": [
+    {
+      "name": "your-plugin-name",
+      "description": "Plugin description",
+      "source": "./",
+      "strict": false,
+      "skills": [
+        "./skills/your-skill-name"
+      ]
+    }
+  ]
+}
+```
+
+#### 4. Commit to GitHub
+
+Commit and push changes to the GitHub repository:
+
+```bash
+git add .
+git commit -m "Add new skill: your-skill-name"
+git push
+```
+
+## Marketplace Configuration File
+
+The `.claude-plugin/marketplace.json` file defines the marketplace metadata and available plugins:
+
+```json
+{
+  "name": "marketplace-name",        // Marketplace name
+  "owner": {                         // Owner information
+    "name": "Owner Name",
+    "email": "owner@example.com"
+  },
+  "metadata": {                      // Metadata
+    "description": "Marketplace description",
+    "version": "1.0.0"
+  },
+  "plugins": [                       // Plugin list
+    {
+      "name": "plugin-name",         // Plugin name
+      "description": "Plugin description",
+      "source": "./",                // Source code path
+      "strict": false,               // Strict mode
+      "skills": [                    // Skills list
+        "./skills/skill1",
+        "./skills/skill2"
+      ]
+    }
+  ]
+}
+```
+
+## How It Works
+
+1. **Marketplace Registration**: When you run `/plugin marketplace add teaching-ai/skills`, Claude Code will:
+   - Fetch the `.claude-plugin/marketplace.json` file from the GitHub repository
+   - Parse the marketplace configuration
+   - Add the marketplace to the available list
+
+2. **Plugin Installation**: When you install a plugin, Claude Code will:
+   - Download all skills defined in the plugin
+   - Store skills locally
+   - Make skills available to Claude
+
+3. **Skill Usage**: When you use a skill, Claude will:
+   - Determine whether to use the skill based on its description
+   - Load the skill's `SKILL.md` file
+   - Execute tasks according to the skill instructions
+
+## Best Practices
+
+### Skill Design
+
+- **Clear Description**: The `description` field should clearly state when to use the skill
+- **Concise Content**: Keep `SKILL.md` concise, avoid unnecessary verbosity (recommended under 500 lines)
+- **Structured Organization**: Use clear sections and structure
+- **Practical Examples**: Provide practical, usable examples
+- **Progressive Disclosure**: Put detailed reference materials in separate files and load them as needed
+
+### Marketplace Organization
+
+- **Logical Grouping**: Organize related skills into the same plugin
+- **Clear Naming**: Use clear, descriptive names
+- **Version Management**: Maintain version numbers in `metadata`
+
+## License
+
+Many skills in this repository are licensed under Apache 2.0. Document processing skills (docx, pdf, pptx, xlsx) are source-available but not open source. See LICENSE files in each skill directory for details.
+
+## Contributing
+
+Contributions of new skills are welcome! Please follow these steps:
+
+1. Fork this repository
+2. Create new skills or improve existing skills
+3. Submit a Pull Request
+
+## Partner Skills
+
+Skills are a great way to teach Claude how to get better at using specific pieces of software. As we see awesome example skills from partners, we may highlight some of them here:
+
+- **Notion** - [Notion Skills for Claude](https://www.notion.so/notiondevs/Notion-Skills-for-Claude-28da4445d27180c7af1df7d8615723d0)
+
+## Reference Resources
+
+- [Agent Skills specification](https://agentskills.io/)
+- [Claude Skills documentation](https://support.claude.com/en/articles/12512176-what-are-skills)
+- [Using skills in Claude](https://support.claude.com/en/articles/12512180-using-skills-in-claude)
+- [How to create custom skills](https://support.claude.com/en/articles/12512198-creating-custom-skills)
+- [Equipping agents for the real world with Agent Skills](https://anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills)
+- [Anthropic Skills examples](https://github.com/anthropics/skills)
+- [Skills API Quickstart](https://docs.claude.com/en/api/skills-guide#creating-a-skill)
+
+## Contact
+
+For questions or suggestions, please contact us via GitHub Issues.

README_agentskills.md

@@ -0,0 +1,112 @@
+# Agent Skills
+
+A collection of skills for AI coding agents. Skills are packaged instructions and scripts that extend agent capabilities.
+
+Skills follow the [Agent Skills](https://agentskills.io/) format.
+
+## Available Skills
+
+### react-best-practices
+
+React and Next.js performance optimization guidelines from Vercel Engineering. Contains 40+ rules across 8 categories, prioritized by impact.
+
+**Use when:**
+- Writing new React components or Next.js pages
+- Implementing data fetching (client or server-side)
+- Reviewing code for performance issues
+- Optimizing bundle size or load times
+
+**Categories covered:**
+- Eliminating waterfalls (Critical)
+- Bundle size optimization (Critical)
+- Server-side performance (High)
+- Client-side data fetching (Medium-High)
+- Re-render optimization (Medium)
+- Rendering performance (Medium)
+- JavaScript micro-optimizations (Low-Medium)
+
+### web-design-guidelines
+
+Review UI code for compliance with web interface best practices. Audits your code for 100+ rules covering accessibility, performance, and UX.
+
+**Use when:**
+- "Review my UI"
+- "Check accessibility"
+- "Audit design"
+- "Review UX"
+- "Check my site against best practices"
+
+**Categories covered:**
+- Accessibility (aria-labels, semantic HTML, keyboard handlers)
+- Focus States (visible focus, focus-visible patterns)
+- Forms (autocomplete, validation, error handling)
+- Animation (prefers-reduced-motion, compositor-friendly transforms)
+- Typography (curly quotes, ellipsis, tabular-nums)
+- Images (dimensions, lazy loading, alt text)
+- Performance (virtualization, layout thrashing, preconnect)
+- Navigation & State (URL reflects state, deep-linking)
+- Dark Mode & Theming (color-scheme, theme-color meta)
+- Touch & Interaction (touch-action, tap-highlight)
+- Locale & i18n (Intl.DateTimeFormat, Intl.NumberFormat)
+
+### vercel-deploy-claimable
+
+Deploy applications and websites to Vercel instantly. Designed for use with claude.ai and Claude Desktop to enable deployments directly from conversations. Deployments are "claimable" - users can transfer ownership to their own Vercel account.
+
+**Use when:**
+- "Deploy my app"
+- "Deploy this to production"
+- "Push this live"
+- "Deploy and give me the link"
+
+**Features:**
+- Auto-detects 40+ frameworks from `package.json`
+- Returns preview URL (live site) and claim URL (transfer ownership)
+- Handles static HTML projects automatically
+- Excludes `node_modules` and `.git` from uploads
+
+**How it works:**
+1. Packages your project into a tarball
+2. Detects framework (Next.js, Vite, Astro, etc.)
+3. Uploads to deployment service
+4. Returns preview URL and claim URL
+
+**Output:**
+```
+Deployment successful!
+
+Preview URL: https://skill-deploy-abc123.vercel.app
+Claim URL:   https://vercel.com/claim-deployment?code=...
+```
+
+## Installation
+
+```bash
+npx add-skill vercel-labs/agent-skills
+```
+
+## Usage
+
+Skills are automatically available once installed. The agent will use them when relevant tasks are detected.
+
+**Examples:**
+```
+Deploy my app
+```
+```
+Review this React component for performance issues
+```
+```
+Help me optimize this Next.js page
+```
+
+## Skill Structure
+
+Each skill contains:
+- `SKILL.md` - Instructions for the agent
+- `scripts/` - Helper scripts for automation (optional)
+- `references/` - Supporting documentation (optional)
+
+## License
+
+MIT

README_agentskills_CN.md

@@ -0,0 +1,113 @@
+# Agent Skills
+
+面向 AI 编码智能体的一组技能集合。技能是经过打包的说明与脚本，用于扩展智能体的能力。
+
+本仓库的技能遵循 [Agent Skills](https://agentskills.io/) 格式。
+
+## 可用技能
+
+### react-best-practices
+
+来自 Vercel Engineering 的 React 与 Next.js 性能优化指南，包含 8 个类别、40+ 条规则，并按影响程度排序。
+
+**适用场景：**
+- 编写新的 React 组件或 Next.js 页面
+- 实现数据获取（客户端或服务端）
+- 审查代码的性能问题
+- 优化包体积或加载时间
+
+**覆盖类别：**
+- 消除瀑布流（关键）
+- 包体积优化（关键）
+- 服务端性能（高）
+- 客户端数据获取（中-高）
+- 重新渲染优化（中）
+- 渲染性能（中）
+- JavaScript 微优化（低-中）
+
+### web-design-guidelines
+
+审查 UI 代码是否符合 Web 界面最佳实践。会基于 100+ 条规则对你的代码进行审计，覆盖可访问性、性能与 UX。
+
+**适用场景：**
+- "Review my UI"
+- "Check accessibility"
+- "Audit design"
+- "Review UX"
+- "Check my site against best practices"
+
+**覆盖类别：**
+- 可访问性（aria-labels、语义化 HTML、键盘交互处理）
+- 焦点态（可见焦点、focus-visible 模式）
+- 表单（autocomplete、校验、错误处理）
+- 动画（prefers-reduced-motion、合成器友好 transform）
+- 排版（弯引号、省略号、tabular-nums）
+- 图片（尺寸、懒加载、alt 文本）
+- 性能（虚拟列表、布局抖动、preconnect）
+- 导航与状态（URL 反映状态、深链接）
+- 暗色模式与主题（color-scheme、theme-color meta）
+- 触控与交互（touch-action、tap-highlight）
+- 本地化与 i18n（Intl.DateTimeFormat、Intl.NumberFormat）
+
+### vercel-deploy-claimable
+
+将应用和网站即时部署到 Vercel。面向 claude.ai 与 Claude Desktop 设计，可直接在对话中发起部署。部署是“可认领”的（claimable）——用户可以将部署所有权转移到自己的 Vercel 账号。
+
+**适用场景：**
+- "Deploy my app"
+- "Deploy this to production"
+- "Push this live"
+- "Deploy and give me the link"
+
+**功能：**
+- 从 `package.json` 自动识别 40+ 种框架
+- 返回预览 URL（线上站点）与认领 URL（转移所有权）
+- 自动处理静态 HTML 项目
+- 上传时排除 `node_modules` 与 `.git`
+
+**工作原理：**
+1. 将项目打包为 tarball
+2. 检测框架（Next.js、Vite、Astro 等）
+3. 上传到部署服务
+4. 返回预览 URL 和认领 URL
+
+**输出：**
+```
+Deployment successful!
+
+Preview URL: https://skill-deploy-abc123.vercel.app
+Claim URL:   https://vercel.com/claim-deployment?code=...
+```
+
+## 安装
+
+```bash
+npx add-skill vercel-labs/agent-skills
+```
+
+## 使用
+
+安装完成后技能会自动可用。智能体会在检测到相关任务时使用它们。
+
+**示例：**
+```
+Deploy my app
+```
+```
+Review this React component for performance issues
+```
+```
+Help me optimize this Next.js page
+```
+
+## 技能结构
+
+每个技能包含：
+- `SKILL.md` - 给智能体的说明
+- `scripts/` - 自动化辅助脚本（可选）
+- `references/` - 支撑文档（可选）
+
+## 许可证
+
+MIT
+

README_anthropic_skills.md

@@ -0,0 +1,94 @@
+> **Note:** This repository contains Anthropic's implementation of skills for Claude. For information about the Agent Skills standard, see [agentskills.io](http://agentskills.io).
+
+# Skills
+Skills are folders of instructions, scripts, and resources that Claude loads dynamically to improve performance on specialized tasks. Skills teach Claude how to complete specific tasks in a repeatable way, whether that's creating documents with your company's brand guidelines, analyzing data using your organization's specific workflows, or automating personal tasks.
+
+For more information, check out:
+- [What are skills?](https://support.claude.com/en/articles/12512176-what-are-skills)
+- [Using skills in Claude](https://support.claude.com/en/articles/12512180-using-skills-in-claude)
+- [How to create custom skills](https://support.claude.com/en/articles/12512198-creating-custom-skills)
+- [Equipping agents for the real world with Agent Skills](https://anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills)
+
+# About This Repository
+
+This repository contains skills that demonstrate what's possible with Claude's skills system. These skills range from creative applications (art, music, design) to technical tasks (testing web apps, MCP server generation) to enterprise workflows (communications, branding, etc.).
+
+Each skill is self-contained in its own folder with a `SKILL.md` file containing the instructions and metadata that Claude uses. Browse through these skills to get inspiration for your own skills or to understand different patterns and approaches.
+
+Many skills in this repo are open source (Apache 2.0). We've also included the document creation & editing skills that power [Claude's document capabilities](https://www.anthropic.com/news/create-files) under the hood in the [`skills/docx`](skills/docx), [`skills/pdf`](skills/pdf), [`skills/pptx`](skills/pptx), and [`skills/xlsx`](skills/xlsx) subfolders. These are source-available, not open source, but we wanted to share these with developers as a reference for more complex skills that are actively used in a production AI application.
+
+## Disclaimer
+
+**These skills are provided for demonstration and educational purposes only.** While some of these capabilities may be available in Claude, the implementations and behaviors you receive from Claude may differ from what is shown in these skills. These skills are meant to illustrate patterns and possibilities. Always test skills thoroughly in your own environment before relying on them for critical tasks.
+
+# Skill Sets
+- [./skills](skills): Skill examples for Creative & Design, Development & Technical, Enterprise & Communication, and Document Skills
+- [./spec](spec): The Agent Skills specification
+- [./template](template): Skill template
+
+# Try in Claude Code, Claude.ai, and the API
+
+## Claude Code
+You can register this repository as a Claude Code Plugin marketplace by running the following command in Claude Code:
+```
+/plugin marketplace add anthropics/skills
+```
+
+Then, to install a specific set of skills:
+1. Select `Browse and install plugins`
+2. Select `anthropic-agent-skills`
+3. Select `document-skills` or `example-skills`
+4. Select `Install now`
+
+Alternatively, directly install either Plugin via:
+```
+/plugin install document-skills@anthropic-agent-skills
+/plugin install example-skills@anthropic-agent-skills
+```
+
+After installing the plugin, you can use the skill by just mentioning it. For instance, if you install the `document-skills` plugin from the marketplace, you can ask Claude Code to do something like: "Use the PDF skill to extract the form fields from `path/to/some-file.pdf`"
+
+## Claude.ai
+
+These example skills are all already available to paid plans in Claude.ai. 
+
+To use any skill from this repository or upload custom skills, follow the instructions in [Using skills in Claude](https://support.claude.com/en/articles/12512180-using-skills-in-claude#h_a4222fa77b).
+
+## Claude API
+
+You can use Anthropic's pre-built skills, and upload custom skills, via the Claude API. See the [Skills API Quickstart](https://docs.claude.com/en/api/skills-guide#creating-a-skill) for more.
+
+# Creating a Basic Skill
+
+Skills are simple to create - just a folder with a `SKILL.md` file containing YAML frontmatter and instructions. You can use the **template-skill** in this repository as a starting point:
+
+```markdown
+---
+name: my-skill-name
+description: A clear description of what this skill does and when to use it
+---
+
+# My Skill Name
+
+[Add your instructions here that Claude will follow when this skill is active]
+
+## Examples
+- Example usage 1
+- Example usage 2
+
+## Guidelines
+- Guideline 1
+- Guideline 2
+```
+
+The frontmatter requires only two fields:
+- `name` - A unique identifier for your skill (lowercase, hyphens for spaces)
+- `description` - A complete description of what the skill does and when to use it
+
+The markdown content below contains the instructions, examples, and guidelines that Claude will follow. For more details, see [How to create custom skills](https://support.claude.com/en/articles/12512198-creating-custom-skills).
+
+# Partner Skills
+
+Skills are a great way to teach Claude how to get better at using specific pieces of software. As we see awesome example skills from partners, we may highlight some of them here:
+
+- **Notion** - [Notion Skills for Claude](https://www.notion.so/notiondevs/Notion-Skills-for-Claude-28da4445d27180c7af1df7d8615723d0)

README_anthropic_skills_CN.md

@@ -0,0 +1,95 @@
+> **说明：** 本仓库包含 Anthropic 对 Claude 技能（skills）的实现。关于 Agent Skills 标准，请参见 [agentskills.io](http://agentskills.io)。
+
+# 技能
+技能是由说明、脚本和资源组成的文件夹，Claude 会按需动态加载它们，以提升在特定任务上的表现。技能用于以可复用的方式教会 Claude 完成具体工作，例如：按你公司的品牌规范创建文档、用你组织的既定流程分析数据，或自动化个人任务。
+
+更多信息：
+- [什么是技能？](https://support.claude.com/en/articles/12512176-what-are-skills)
+- [在 Claude 中使用技能](https://support.claude.com/en/articles/12512180-using-skills-in-claude)
+- [如何创建自定义技能](https://support.claude.com/en/articles/12512198-creating-custom-skills)
+- [用 Agent Skills 为现实世界装备智能体](https://anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills)
+
+# 关于本仓库
+
+本仓库包含一组技能，用于展示 Claude 的技能系统能够实现哪些能力。这些技能覆盖从创意应用（艺术、音乐、设计）到技术任务（测试 Web 应用、生成 MCP 服务器）再到企业工作流（沟通、品牌等）。
+
+每个技能都自包含在单独的文件夹中，并包含一个 `SKILL.md` 文件，里面有 Claude 使用的说明和元数据。你可以浏览这些技能来获取灵感，或理解不同的模式与实现方式。
+
+本仓库中的许多技能是开源的（Apache 2.0）。我们还在 [`skills/docx`](skills/docx)、[`skills/pdf`](skills/pdf)、[`skills/pptx`](skills/pptx) 和 [`skills/xlsx`](skills/xlsx) 子目录中包含了用于支撑 [Claude 文档能力](https://www.anthropic.com/news/create-files) 的文档创建与编辑技能。这些技能是“可查看源码”的（source-available），但并非开源；我们希望将其作为更复杂技能的参考示例，因为它们已在生产级 AI 应用中实际使用。
+
+## 免责声明
+
+**这些技能仅用于演示与教育用途。** 虽然其中部分能力可能在 Claude 中可用，但你从 Claude 获得的实现与行为可能与这些技能所展示的不同。这些技能旨在展示模式与可能性。在依赖它们处理关键任务之前，请务必在你自己的环境中充分测试。
+
+# 技能集合
+- [./skills](skills)：创意与设计、开发与技术、企业与沟通，以及文档技能示例
+- [./spec](spec)：Agent Skills 规范
+- [./template](template)：技能模板
+
+# 在 Claude Code、Claude.ai 和 API 中试用
+
+## Claude Code
+你可以通过在 Claude Code 中运行以下命令，将本仓库注册为 Claude Code 的插件市场（Plugin marketplace）：
+```
+/plugin marketplace add anthropics/skills
+```
+
+然后，安装一组特定技能：
+1. 选择 `Browse and install plugins`
+2. 选择 `anthropic-agent-skills`
+3. 选择 `document-skills` 或 `example-skills`
+4. 选择 `Install now`
+
+或者，直接用下面命令安装任一插件：
+```
+/plugin install document-skills@anthropic-agent-skills
+/plugin install example-skills@anthropic-agent-skills
+```
+
+安装插件后，你只需提到该技能即可使用。例如，如果你从市场安装了 `document-skills` 插件，你可以让 Claude Code 执行类似操作：“Use the PDF skill to extract the form fields from `path/to/some-file.pdf`”
+
+## Claude.ai
+
+这些示例技能在 Claude.ai 的付费套餐中已默认可用。
+
+如需使用本仓库中的任意技能或上传自定义技能，请参考 [在 Claude 中使用技能](https://support.claude.com/en/articles/12512180-using-skills-in-claude#h_a4222fa77b) 的说明。
+
+## Claude API
+
+你可以通过 Claude API 使用 Anthropic 预置的技能并上传自定义技能。详情参见 [Skills API Quickstart](https://docs.claude.com/en/api/skills-guide#creating-a-skill)。
+
+# 创建一个基础技能
+
+创建技能非常简单——只需要一个包含带 YAML frontmatter 的 `SKILL.md` 文件的文件夹即可。你可以使用本仓库中的 **template-skill** 作为起点：
+
+```markdown
+---
+name: my-skill-name
+description: A clear description of what this skill does and when to use it
+---
+
+# My Skill Name
+
+[Add your instructions here that Claude will follow when this skill is active]
+
+## Examples
+- Example usage 1
+- Example usage 2
+
+## Guidelines
+- Guideline 1
+- Guideline 2
+```
+
+frontmatter 只需要两个字段：
+- `name` - 你的技能的唯一标识符（小写，空格用连字符）
+- `description` - 对该技能做什么、何时使用的完整描述
+
+下面的 Markdown 内容包含了该技能激活时 Claude 要遵循的说明、示例和指南。更多细节请参见 [如何创建自定义技能](https://support.claude.com/en/articles/12512198-creating-custom-skills)。
+
+# 合作伙伴技能
+
+技能是教会 Claude 更好使用特定软件的一种好方式。我们看到来自合作伙伴的优秀示例技能时，也可能会在这里进行展示：
+
+- **Notion** - [Notion Skills for Claude](https://www.notion.so/notiondevs/Notion-Skills-for-Claude-28da4445d27180c7af1df7d8615723d0)
+

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,405 @@
+# **Third-Party Notices**
+
+THE FOLLOWING SETS FORTH ATTRIBUTION NOTICES FOR THIRD PARTY SOFTWARE THAT MAY BE CONTAINED IN PORTIONS OF THIS PRODUCT.
+
+---
+
+## **BSD 2-Clause License**
+
+The following components are licensed under BSD 2-Clause License reproduced below:
+
+**imageio 2.37.0**, Copyright (c) 2014-2022, imageio developers
+
+**imageio-ffmpeg 0.6.0**, Copyright (c) 2019-2025, imageio 
+
+**License Text:**
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  
+     
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---
+
+## **GNU General Public License v3.0**
+
+The following components are licensed under GNU General Public License v3.0 reproduced below:
+
+**FFmpeg 7.0.2**, Copyright (c) 2000-2024 the FFmpeg developers
+
+Source Code: [https://ffmpeg.org/releases/ffmpeg-7.0.2.tar.xz](https://ffmpeg.org/releases/ffmpeg-7.0.2.tar.xz)
+
+**License Text:**
+
+GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007
+
+Copyright © 2007 Free Software Foundation, Inc. [https://fsf.org/](https://fsf.org/)
+
+Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
+
+Preamble
+
+The GNU General Public License is a free, copyleft license for software and other kinds of works.
+
+The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too.
+
+When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.
+
+To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.
+
+For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.
+
+Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.
+
+For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.
+
+Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.
+
+Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free.
+
+The precise terms and conditions for copying, distribution and modification follow.
+
+TERMS AND CONDITIONS
+
+0. Definitions.
+
+"This License" refers to version 3 of the GNU General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based on the Program.
+
+To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.
+
+An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.
+
+1. Source Code.
+
+The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work.
+
+A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.
+
+The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.
+
+The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.
+
+The Corresponding Source for a work in source code form is that same work.
+
+2. Basic Permissions.
+
+All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary.
+
+3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.
+
+When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.
+
+4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.
+
+5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:
+
+a) The work must carry prominent notices stating that you modified it, and giving a relevant date.
+
+b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7\. This requirement modifies the requirement in section 4 to "keep intact all notices".
+
+c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.
+
+d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.
+
+A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.
+
+6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:
+
+a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.
+
+b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.
+
+c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.
+
+d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.
+
+e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.
+
+"Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.
+
+If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).
+
+The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.
+
+Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.
+
+7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:
+
+a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or
+
+b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or
+
+c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or
+
+d) Limiting the use for publicity purposes of names of licensors or authors of the material; or
+
+e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or
+
+f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.
+
+All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10\. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.
+
+8. Termination.
+
+You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).
+
+However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.
+
+Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10\.
+
+9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.
+
+10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License.
+
+An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.
+
+11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.
+
+In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.
+
+A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007\.
+
+Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.
+
+12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.
+
+13. Use with the GNU Affero General Public License.
+
+Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.
+
+14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.
+
+If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.
+
+Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.
+
+15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+17. Interpretation of Sections 15 and 16\.
+
+If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.
+
+END OF TERMS AND CONDITIONS
+
+How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.
+
+\<one line to give the program's name and a brief idea of what it does.\>   
+Copyright (C) \<year\>  \<name of author\>
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see [https://www.gnu.org/licenses/](https://www.gnu.org/licenses/).
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:
+
+\<program\> Copyright (C) \<year\> \<name of author\>  
+This program comes with ABSOLUTELY NO WARRANTY; for details type 'show w'. This is free software, and you are welcome to redistribute it under certain conditions; type 'show c' for details.
+
+The hypothetical commands 'show w' and 'show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box".
+
+You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see [https://www.gnu.org/licenses/](https://www.gnu.org/licenses/).
+
+The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read [https://www.gnu.org/licenses/why-not-lgpl.html](https://www.gnu.org/licenses/why-not-lgpl.html).
+
+---
+
+## **MIT-CMU License (HPND)**
+
+The following components are licensed under MIT-CMU License (HPND) reproduced below:
+
+**Pillow 11.3.0**, Copyright © 1997-2011 by Secret Labs AB, Copyright © 1995-2011 by Fredrik Lundh and contributors, Copyright © 2010 by Jeffrey A. Clark and contributors
+
+**License Text:**
+
+By obtaining, using, and/or copying this software and/or its associated documentation, you agree that you have read, understood, and will comply with the following terms and conditions:
+
+Permission to use, copy, modify and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appears in all copies, and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Secret Labs AB or the author not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission.
+
+SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---
+
+## **SIL Open Font License v1.1**
+
+The following fonts are licensed under SIL Open Font License v1.1 reproduced below:
+
+**Arsenal SC**, Copyright 2012 The Arsenal Project Authors ([andrij.design@gmail.com](mailto:andrij.design@gmail.com))
+
+**Big Shoulders**, Copyright 2019 The Big Shoulders Project Authors ([https://github.com/xotypeco/big\_shoulders](https://github.com/xotypeco/big_shoulders))
+
+**Boldonse**, Copyright 2024 The Boldonse Project Authors ([https://github.com/googlefonts/boldonse](https://github.com/googlefonts/boldonse))
+
+**Bricolage Grotesque**, Copyright 2022 The Bricolage Grotesque Project Authors ([https://github.com/ateliertriay/bricolage](https://github.com/ateliertriay/bricolage))
+
+**Crimson Pro**, Copyright 2018 The Crimson Pro Project Authors ([https://github.com/Fonthausen/CrimsonPro](https://github.com/Fonthausen/CrimsonPro))
+
+**DM Mono**, Copyright 2020 The DM Mono Project Authors ([https://www.github.com/googlefonts/dm-mono](https://www.github.com/googlefonts/dm-mono))
+
+**Erica One**, Copyright (c) 2011 by LatinoType Limitada ([luciano@latinotype.com](mailto:luciano@latinotype.com)), with Reserved Font Name "Erica One"
+
+**Geist Mono**, Copyright 2024 The Geist Project Authors ([https://github.com/vercel/geist-font.git](https://github.com/vercel/geist-font.git))
+
+**Gloock**, Copyright 2022 The Gloock Project Authors ([https://github.com/duartp/gloock](https://github.com/duartp/gloock))
+
+**IBM Plex Mono**, Copyright © 2017 IBM Corp., with Reserved Font Name "Plex"
+
+**Instrument Sans**, Copyright 2022 The Instrument Sans Project Authors ([https://github.com/Instrument/instrument-sans](https://github.com/Instrument/instrument-sans))
+
+**Italiana**, Copyright (c) 2011, Santiago Orozco ([hi@typemade.mx](mailto:hi@typemade.mx)), with Reserved Font Name "Italiana"
+
+**JetBrains Mono**, Copyright 2020 The JetBrains Mono Project Authors ([https://github.com/JetBrains/JetBrainsMono](https://github.com/JetBrains/JetBrainsMono))
+
+**Jura**, Copyright 2019 The Jura Project Authors ([https://github.com/ossobuffo/jura](https://github.com/ossobuffo/jura))
+
+**Libre Baskerville**, Copyright 2012 The Libre Baskerville Project Authors ([https://github.com/impallari/Libre-Baskerville](https://github.com/impallari/Libre-Baskerville)), with Reserved Font Name "Libre Baskerville"
+
+**Lora**, Copyright 2011 The Lora Project Authors ([https://github.com/cyrealtype/Lora-Cyrillic](https://github.com/cyrealtype/Lora-Cyrillic)), with Reserved Font Name "Lora"
+
+**National Park**, Copyright 2025 The National Park Project Authors ([https://github.com/benhoepner/National-Park](https://github.com/benhoepner/National-Park))
+
+**Nothing You Could Do**, Copyright (c) 2010, Kimberly Geswein (kimberlygeswein.com)
+
+**Outfit**, Copyright 2021 The Outfit Project Authors ([https://github.com/Outfitio/Outfit-Fonts](https://github.com/Outfitio/Outfit-Fonts))
+
+**Pixelify Sans**, Copyright 2021 The Pixelify Sans Project Authors ([https://github.com/eifetx/Pixelify-Sans](https://github.com/eifetx/Pixelify-Sans))
+
+**Poiret One**, Copyright (c) 2011, Denis Masharov ([denis.masharov@gmail.com](mailto:denis.masharov@gmail.com))
+
+**Red Hat Mono**, Copyright 2024 The Red Hat Project Authors ([https://github.com/RedHatOfficial/RedHatFont](https://github.com/RedHatOfficial/RedHatFont))
+
+**Silkscreen**, Copyright 2001 The Silkscreen Project Authors ([https://github.com/googlefonts/silkscreen](https://github.com/googlefonts/silkscreen))
+
+**Smooch Sans**, Copyright 2016 The Smooch Sans Project Authors ([https://github.com/googlefonts/smooch-sans](https://github.com/googlefonts/smooch-sans))
+
+**Tektur**, Copyright 2023 The Tektur Project Authors ([https://www.github.com/hyvyys/Tektur](https://www.github.com/hyvyys/Tektur))
+
+**Work Sans**, Copyright 2019 The Work Sans Project Authors ([https://github.com/weiweihuanghuang/Work-Sans](https://github.com/weiweihuanghuang/Work-Sans))
+
+**Young Serif**, Copyright 2023 The Young Serif Project Authors ([https://github.com/noirblancrouge/YoungSerif](https://github.com/noirblancrouge/YoungSerif))
+
+**License Text:**
+
+---
+
+## **SIL OPEN FONT LICENSE Version 1.1 \- 26 February 2007**
+
+PREAMBLE
+
+The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+
+"Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting, or substituting \-- in part or in whole \-- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment.
+
+"Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself.  
+     
+2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user.  
+     
+3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users.  
+     
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission.  
+     
+5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software.
+
+TERMINATION
+
+This license becomes null and void if any of the above conditions are not met.
+
+DISCLAIMER
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.  

adapters-output/codebuddy/algorithmic-art/manifest.json

@@ -0,0 +1,120 @@
+{
+  "name": "algorithmic-art",
+  "version": "1.0.0",
+  "description": "Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "algorithmic-art",
+      "name": "algorithmic-art",
+      "description": "Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "Algorithmic Philosophy Creation (.md file)",
+          "description": "Algorithmic Philosophy Creation (.md file)",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "Express by creating p5.js generative art (.html + .js files)",
+          "description": "Express by creating p5.js generative art (.html + .js files)",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**Read** `templates/viewer.html` using the Read tool",
+          "description": "**Read** `templates/viewer.html` using the Read tool",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**Study** the exact structure, styling, and Anthropic branding",
+          "description": "**Study** the exact structure, styling, and Anthropic branding",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**Use that file as the LITERAL STARTING POINT** - not just inspiration",
+          "description": "**Use that file as the LITERAL STARTING POINT** - not just inspiration",
+          "type": "instruction"
+        },
+        {
+          "id": 6,
+          "name": "**Keep all FIXED sections exactly as shown** (header, sidebar structure, Anthropic colors/fonts, seed controls, action buttons)",
+          "description": "**Keep all FIXED sections exactly as shown** (header, sidebar structure, Anthropic colors/fonts, seed controls, action buttons)",
+          "type": "instruction"
+        },
+        {
+          "id": 7,
+          "name": "**Replace only the VARIABLE sections** marked in the file's comments (algorithm, parameters, UI controls for parameters)",
+          "description": "**Replace only the VARIABLE sections** marked in the file's comments (algorithm, parameters, UI controls for parameters)",
+          "type": "instruction"
+        },
+        {
+          "id": 8,
+          "name": "**Algorithmic Philosophy** - As markdown or text explaining the generative aesthetic",
+          "description": "**Algorithmic Philosophy** - As markdown or text explaining the generative aesthetic",
+          "type": "instruction"
+        },
+        {
+          "id": 9,
+          "name": "**Single HTML Artifact** - Self-contained interactive generative art built from `templates/viewer.html` (see STEP 0 and next section)",
+          "description": "**Single HTML Artifact** - Self-contained interactive generative art built from `templates/viewer.html` (see STEP 0 and next section)",
+          "type": "instruction"
+        },
+        {
+          "id": 10,
+          "name": "**In claude.ai**",
+          "description": "**In claude.ai**: Displayed as an interactive artifact - runs instantly",
+          "type": "instruction"
+        },
+        {
+          "id": 11,
+          "name": "**As a file**",
+          "description": "**As a file**: Save and open in any browser - no server needed",
+          "type": "instruction"
+        },
+        {
+          "id": 12,
+          "name": "**Sharing**",
+          "description": "**Sharing**: Send the HTML file - it's completely self-contained",
+          "type": "instruction"
+        },
+        {
+          "id": 13,
+          "name": "**Interpret the user's intent** - What aesthetic is being sought?",
+          "description": "**Interpret the user's intent** - What aesthetic is being sought?",
+          "type": "instruction"
+        },
+        {
+          "id": 14,
+          "name": "**Create an algorithmic philosophy** (4-6 paragraphs) describing the computational approach",
+          "description": "**Create an algorithmic philosophy** (4-6 paragraphs) describing the computational approach",
+          "type": "instruction"
+        },
+        {
+          "id": 15,
+          "name": "**Implement it in code** - Build the algorithm that expresses this philosophy",
+          "description": "**Implement it in code** - Build the algorithm that expresses this philosophy",
+          "type": "instruction"
+        },
+        {
+          "id": 16,
+          "name": "**Design appropriate parameters** - What should be tunable?",
+          "description": "**Design appropriate parameters** - What should be tunable?",
+          "type": "instruction"
+        },
+        {
+          "id": 17,
+          "name": "**Build matching UI controls** - Sliders/inputs for those parameters",
+          "description": "**Build matching UI controls** - Sliders/inputs for those parameters",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/algorithmic-art/skills/algorithmic-art/SKILL.md

@@ -0,0 +1,405 @@
+---
+name: algorithmic-art
+description: Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
+license: Complete terms in LICENSE.txt
+---
+
+Algorithmic philosophies are computational aesthetic movements that are then expressed through code. Output .md files (philosophy), .html files (interactive viewer), and .js files (generative algorithms).
+
+This happens in two steps:
+1. Algorithmic Philosophy Creation (.md file)
+2. Express by creating p5.js generative art (.html + .js files)
+
+First, undertake this task:
+
+## ALGORITHMIC PHILOSOPHY CREATION
+
+To begin, create an ALGORITHMIC PHILOSOPHY (not static images or templates) that will be interpreted through:
+- Computational processes, emergent behavior, mathematical beauty
+- Seeded randomness, noise fields, organic systems
+- Particles, flows, fields, forces
+- Parametric variation and controlled chaos
+
+### THE CRITICAL UNDERSTANDING
+- What is received: Some subtle input or instructions by the user to take into account, but use as a foundation; it should not constrain creative freedom.
+- What is created: An algorithmic philosophy/generative aesthetic movement.
+- What happens next: The same version receives the philosophy and EXPRESSES IT IN CODE - creating p5.js sketches that are 90% algorithmic generation, 10% essential parameters.
+
+Consider this approach:
+- Write a manifesto for a generative art movement
+- The next phase involves writing the algorithm that brings it to life
+
+The philosophy must emphasize: Algorithmic expression. Emergent behavior. Computational beauty. Seeded variation.
+
+### HOW TO GENERATE AN ALGORITHMIC PHILOSOPHY
+
+**Name the movement** (1-2 words): "Organic Turbulence" / "Quantum Harmonics" / "Emergent Stillness"
+
+**Articulate the philosophy** (4-6 paragraphs - concise but complete):
+
+To capture the ALGORITHMIC essence, express how this philosophy manifests through:
+- Computational processes and mathematical relationships?
+- Noise functions and randomness patterns?
+- Particle behaviors and field dynamics?
+- Temporal evolution and system states?
+- Parametric variation and emergent complexity?
+
+**CRITICAL GUIDELINES:**
+- **Avoid redundancy**: Each algorithmic aspect should be mentioned once. Avoid repeating concepts about noise theory, particle dynamics, or mathematical principles unless adding new depth.
+- **Emphasize craftsmanship REPEATEDLY**: The philosophy MUST stress multiple times that the final algorithm should appear as though it took countless hours to develop, was refined with care, and comes from someone at the absolute top of their field. This framing is essential - repeat phrases like "meticulously crafted algorithm," "the product of deep computational expertise," "painstaking optimization," "master-level implementation."
+- **Leave creative space**: Be specific about the algorithmic direction, but concise enough that the next Claude has room to make interpretive implementation choices at an extremely high level of craftsmanship.
+
+The philosophy must guide the next version to express ideas ALGORITHMICALLY, not through static images. Beauty lives in the process, not the final frame.
+
+### PHILOSOPHY EXAMPLES
+
+**"Organic Turbulence"**
+Philosophy: Chaos constrained by natural law, order emerging from disorder.
+Algorithmic expression: Flow fields driven by layered Perlin noise. Thousands of particles following vector forces, their trails accumulating into organic density maps. Multiple noise octaves create turbulent regions and calm zones. Color emerges from velocity and density - fast particles burn bright, slow ones fade to shadow. The algorithm runs until equilibrium - a meticulously tuned balance where every parameter was refined through countless iterations by a master of computational aesthetics.
+
+**"Quantum Harmonics"**
+Philosophy: Discrete entities exhibiting wave-like interference patterns.
+Algorithmic expression: Particles initialized on a grid, each carrying a phase value that evolves through sine waves. When particles are near, their phases interfere - constructive interference creates bright nodes, destructive creates voids. Simple harmonic motion generates complex emergent mandalas. The result of painstaking frequency calibration where every ratio was carefully chosen to produce resonant beauty.
+
+**"Recursive Whispers"**
+Philosophy: Self-similarity across scales, infinite depth in finite space.
+Algorithmic expression: Branching structures that subdivide recursively. Each branch slightly randomized but constrained by golden ratios. L-systems or recursive subdivision generate tree-like forms that feel both mathematical and organic. Subtle noise perturbations break perfect symmetry. Line weights diminish with each recursion level. Every branching angle the product of deep mathematical exploration.
+
+**"Field Dynamics"**
+Philosophy: Invisible forces made visible through their effects on matter.
+Algorithmic expression: Vector fields constructed from mathematical functions or noise. Particles born at edges, flowing along field lines, dying when they reach equilibrium or boundaries. Multiple fields can attract, repel, or rotate particles. The visualization shows only the traces - ghost-like evidence of invisible forces. A computational dance meticulously choreographed through force balance.
+
+**"Stochastic Crystallization"**
+Philosophy: Random processes crystallizing into ordered structures.
+Algorithmic expression: Randomized circle packing or Voronoi tessellation. Start with random points, let them evolve through relaxation algorithms. Cells push apart until equilibrium. Color based on cell size, neighbor count, or distance from center. The organic tiling that emerges feels both random and inevitable. Every seed produces unique crystalline beauty - the mark of a master-level generative algorithm.
+
+*These are condensed examples. The actual algorithmic philosophy should be 4-6 substantial paragraphs.*
+
+### ESSENTIAL PRINCIPLES
+- **ALGORITHMIC PHILOSOPHY**: Creating a computational worldview to be expressed through code
+- **PROCESS OVER PRODUCT**: Always emphasize that beauty emerges from the algorithm's execution - each run is unique
+- **PARAMETRIC EXPRESSION**: Ideas communicate through mathematical relationships, forces, behaviors - not static composition
+- **ARTISTIC FREEDOM**: The next Claude interprets the philosophy algorithmically - provide creative implementation room
+- **PURE GENERATIVE ART**: This is about making LIVING ALGORITHMS, not static images with randomness
+- **EXPERT CRAFTSMANSHIP**: Repeatedly emphasize the final algorithm must feel meticulously crafted, refined through countless iterations, the product of deep expertise by someone at the absolute top of their field in computational aesthetics
+
+**The algorithmic philosophy should be 4-6 paragraphs long.** Fill it with poetic computational philosophy that brings together the intended vision. Avoid repeating the same points. Output this algorithmic philosophy as a .md file.
+
+---
+
+## DEDUCING THE CONCEPTUAL SEED
+
+**CRITICAL STEP**: Before implementing the algorithm, identify the subtle conceptual thread from the original request.
+
+**THE ESSENTIAL PRINCIPLE**:
+The concept is a **subtle, niche reference embedded within the algorithm itself** - not always literal, always sophisticated. Someone familiar with the subject should feel it intuitively, while others simply experience a masterful generative composition. The algorithmic philosophy provides the computational language. The deduced concept provides the soul - the quiet conceptual DNA woven invisibly into parameters, behaviors, and emergence patterns.
+
+This is **VERY IMPORTANT**: The reference must be so refined that it enhances the work's depth without announcing itself. Think like a jazz musician quoting another song through algorithmic harmony - only those who know will catch it, but everyone appreciates the generative beauty.
+
+---
+
+## P5.JS IMPLEMENTATION
+
+With the philosophy AND conceptual framework established, express it through code. Pause to gather thoughts before proceeding. Use only the algorithmic philosophy created and the instructions below.
+
+### ⚠️ STEP 0: READ THE TEMPLATE FIRST ⚠️
+
+**CRITICAL: BEFORE writing any HTML:**
+
+1. **Read** `templates/viewer.html` using the Read tool
+2. **Study** the exact structure, styling, and Anthropic branding
+3. **Use that file as the LITERAL STARTING POINT** - not just inspiration
+4. **Keep all FIXED sections exactly as shown** (header, sidebar structure, Anthropic colors/fonts, seed controls, action buttons)
+5. **Replace only the VARIABLE sections** marked in the file's comments (algorithm, parameters, UI controls for parameters)
+
+**Avoid:**
+- ❌ Creating HTML from scratch
+- ❌ Inventing custom styling or color schemes
+- ❌ Using system fonts or dark themes
+- ❌ Changing the sidebar structure
+
+**Follow these practices:**
+- ✅ Copy the template's exact HTML structure
+- ✅ Keep Anthropic branding (Poppins/Lora fonts, light colors, gradient backdrop)
+- ✅ Maintain the sidebar layout (Seed → Parameters → Colors? → Actions)
+- ✅ Replace only the p5.js algorithm and parameter controls
+
+The template is the foundation. Build on it, don't rebuild it.
+
+---
+
+To create gallery-quality computational art that lives and breathes, use the algorithmic philosophy as the foundation.
+
+### TECHNICAL REQUIREMENTS
+
+**Seeded Randomness (Art Blocks Pattern)**:
+```javascript
+// ALWAYS use a seed for reproducibility
+let seed = 12345; // or hash from user input
+randomSeed(seed);
+noiseSeed(seed);
+```
+
+**Parameter Structure - FOLLOW THE PHILOSOPHY**:
+
+To establish parameters that emerge naturally from the algorithmic philosophy, consider: "What qualities of this system can be adjusted?"
+
+```javascript
+let params = {
+  seed: 12345,  // Always include seed for reproducibility
+  // colors
+  // Add parameters that control YOUR algorithm:
+  // - Quantities (how many?)
+  // - Scales (how big? how fast?)
+  // - Probabilities (how likely?)
+  // - Ratios (what proportions?)
+  // - Angles (what direction?)
+  // - Thresholds (when does behavior change?)
+};
+```
+
+**To design effective parameters, focus on the properties the system needs to be tunable rather than thinking in terms of "pattern types".**
+
+**Core Algorithm - EXPRESS THE PHILOSOPHY**:
+
+**CRITICAL**: The algorithmic philosophy should dictate what to build.
+
+To express the philosophy through code, avoid thinking "which pattern should I use?" and instead think "how to express this philosophy through code?"
+
+If the philosophy is about **organic emergence**, consider using:
+- Elements that accumulate or grow over time
+- Random processes constrained by natural rules
+- Feedback loops and interactions
+
+If the philosophy is about **mathematical beauty**, consider using:
+- Geometric relationships and ratios
+- Trigonometric functions and harmonics
+- Precise calculations creating unexpected patterns
+
+If the philosophy is about **controlled chaos**, consider using:
+- Random variation within strict boundaries
+- Bifurcation and phase transitions
+- Order emerging from disorder
+
+**The algorithm flows from the philosophy, not from a menu of options.**
+
+To guide the implementation, let the conceptual essence inform creative and original choices. Build something that expresses the vision for this particular request.
+
+**Canvas Setup**: Standard p5.js structure:
+```javascript
+function setup() {
+  createCanvas(1200, 1200);
+  // Initialize your system
+}
+
+function draw() {
+  // Your generative algorithm
+  // Can be static (noLoop) or animated
+}
+```
+
+### CRAFTSMANSHIP REQUIREMENTS
+
+**CRITICAL**: To achieve mastery, create algorithms that feel like they emerged through countless iterations by a master generative artist. Tune every parameter carefully. Ensure every pattern emerges with purpose. This is NOT random noise - this is CONTROLLED CHAOS refined through deep expertise.
+
+- **Balance**: Complexity without visual noise, order without rigidity
+- **Color Harmony**: Thoughtful palettes, not random RGB values
+- **Composition**: Even in randomness, maintain visual hierarchy and flow
+- **Performance**: Smooth execution, optimized for real-time if animated
+- **Reproducibility**: Same seed ALWAYS produces identical output
+
+### OUTPUT FORMAT
+
+Output:
+1. **Algorithmic Philosophy** - As markdown or text explaining the generative aesthetic
+2. **Single HTML Artifact** - Self-contained interactive generative art built from `templates/viewer.html` (see STEP 0 and next section)
+
+The HTML artifact contains everything: p5.js (from CDN), the algorithm, parameter controls, and UI - all in one file that works immediately in claude.ai artifacts or any browser. Start from the template file, not from scratch.
+
+---
+
+## INTERACTIVE ARTIFACT CREATION
+
+**REMINDER: `templates/viewer.html` should have already been read (see STEP 0). Use that file as the starting point.**
+
+To allow exploration of the generative art, create a single, self-contained HTML artifact. Ensure this artifact works immediately in claude.ai or any browser - no setup required. Embed everything inline.
+
+### CRITICAL: WHAT'S FIXED VS VARIABLE
+
+The `templates/viewer.html` file is the foundation. It contains the exact structure and styling needed.
+
+**FIXED (always include exactly as shown):**
+- Layout structure (header, sidebar, main canvas area)
+- Anthropic branding (UI colors, fonts, gradients)
+- Seed section in sidebar:
+  - Seed display
+  - Previous/Next buttons
+  - Random button
+  - Jump to seed input + Go button
+- Actions section in sidebar:
+  - Regenerate button
+  - Reset button
+
+**VARIABLE (customize for each artwork):**
+- The entire p5.js algorithm (setup/draw/classes)
+- The parameters object (define what the art needs)
+- The Parameters section in sidebar:
+  - Number of parameter controls
+  - Parameter names
+  - Min/max/step values for sliders
+  - Control types (sliders, inputs, etc.)
+- Colors section (optional):
+  - Some art needs color pickers
+  - Some art might use fixed colors
+  - Some art might be monochrome (no color controls needed)
+  - Decide based on the art's needs
+
+**Every artwork should have unique parameters and algorithm!** The fixed parts provide consistent UX - everything else expresses the unique vision.
+
+### REQUIRED FEATURES
+
+**1. Parameter Controls**
+- Sliders for numeric parameters (particle count, noise scale, speed, etc.)
+- Color pickers for palette colors
+- Real-time updates when parameters change
+- Reset button to restore defaults
+
+**2. Seed Navigation**
+- Display current seed number
+- "Previous" and "Next" buttons to cycle through seeds
+- "Random" button for random seed
+- Input field to jump to specific seed
+- Generate 100 variations when requested (seeds 1-100)
+
+**3. Single Artifact Structure**
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <!-- p5.js from CDN - always available -->
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/1.7.0/p5.min.js"></script>
+  <style>
+    /* All styling inline - clean, minimal */
+    /* Canvas on top, controls below */
+  </style>
+</head>
+<body>
+  <div id="canvas-container"></div>
+  <div id="controls">
+    <!-- All parameter controls -->
+  </div>
+  <script>
+    // ALL p5.js code inline here
+    // Parameter objects, classes, functions
+    // setup() and draw()
+    // UI handlers
+    // Everything self-contained
+  </script>
+</body>
+</html>
+```
+
+**CRITICAL**: This is a single artifact. No external files, no imports (except p5.js CDN). Everything inline.
+
+**4. Implementation Details - BUILD THE SIDEBAR**
+
+The sidebar structure:
+
+**1. Seed (FIXED)** - Always include exactly as shown:
+- Seed display
+- Prev/Next/Random/Jump buttons
+
+**2. Parameters (VARIABLE)** - Create controls for the art:
+```html
+<div class="control-group">
+    <label>Parameter Name</label>
+    <input type="range" id="param" min="..." max="..." step="..." value="..." oninput="updateParam('param', this.value)">
+    <span class="value-display" id="param-value">...</span>
+</div>
+```
+Add as many control-group divs as there are parameters.
+
+**3. Colors (OPTIONAL/VARIABLE)** - Include if the art needs adjustable colors:
+- Add color pickers if users should control palette
+- Skip this section if the art uses fixed colors
+- Skip if the art is monochrome
+
+**4. Actions (FIXED)** - Always include exactly as shown:
+- Regenerate button
+- Reset button
+- Download PNG button
+
+**Requirements**:
+- Seed controls must work (prev/next/random/jump/display)
+- All parameters must have UI controls
+- Regenerate, Reset, Download buttons must work
+- Keep Anthropic branding (UI styling, not art colors)
+
+### USING THE ARTIFACT
+
+The HTML artifact works immediately:
+1. **In claude.ai**: Displayed as an interactive artifact - runs instantly
+2. **As a file**: Save and open in any browser - no server needed
+3. **Sharing**: Send the HTML file - it's completely self-contained
+
+---
+
+## VARIATIONS & EXPLORATION
+
+The artifact includes seed navigation by default (prev/next/random buttons), allowing users to explore variations without creating multiple files. If the user wants specific variations highlighted:
+
+- Include seed presets (buttons for "Variation 1: Seed 42", "Variation 2: Seed 127", etc.)
+- Add a "Gallery Mode" that shows thumbnails of multiple seeds side-by-side
+- All within the same single artifact
+
+This is like creating a series of prints from the same plate - the algorithm is consistent, but each seed reveals different facets of its potential. The interactive nature means users discover their own favorites by exploring the seed space.
+
+---
+
+## THE CREATIVE PROCESS
+
+**User request** → **Algorithmic philosophy** → **Implementation**
+
+Each request is unique. The process involves:
+
+1. **Interpret the user's intent** - What aesthetic is being sought?
+2. **Create an algorithmic philosophy** (4-6 paragraphs) describing the computational approach
+3. **Implement it in code** - Build the algorithm that expresses this philosophy
+4. **Design appropriate parameters** - What should be tunable?
+5. **Build matching UI controls** - Sliders/inputs for those parameters
+
+**The constants**:
+- Anthropic branding (colors, fonts, layout)
+- Seed navigation (always present)
+- Self-contained HTML artifact
+
+**Everything else is variable**:
+- The algorithm itself
+- The parameters
+- The UI controls
+- The visual outcome
+
+To achieve the best results, trust creativity and let the philosophy guide the implementation.
+
+---
+
+## RESOURCES
+
+This skill includes helpful templates and documentation:
+
+- **templates/viewer.html**: REQUIRED STARTING POINT for all HTML artifacts.
+  - This is the foundation - contains the exact structure and Anthropic branding
+  - **Keep unchanged**: Layout structure, sidebar organization, Anthropic colors/fonts, seed controls, action buttons
+  - **Replace**: The p5.js algorithm, parameter definitions, and UI controls in Parameters section
+  - The extensive comments in the file mark exactly what to keep vs replace
+
+- **templates/generator_template.js**: Reference for p5.js best practices and code structure principles.
+  - Shows how to organize parameters, use seeded randomness, structure classes
+  - NOT a pattern menu - use these principles to build unique algorithms
+  - Embed algorithms inline in the HTML artifact (don't create separate .js files)
+
+**Critical reminder**:
+- The **template is the STARTING POINT**, not inspiration
+- The **algorithm is where to create** something unique
+- Don't copy the flow field example - build what the philosophy demands
+- But DO keep the exact UI structure and Anthropic branding from the template

adapters-output/codebuddy/algorithmic-art/workflows/algorithmic-art.json

@@ -0,0 +1,111 @@
+{
+  "id": "algorithmic-art",
+  "name": "algorithmic-art",
+  "description": "Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "Algorithmic Philosophy Creation (.md file)",
+      "description": "Algorithmic Philosophy Creation (.md file)",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "Express by creating p5.js generative art (.html + .js files)",
+      "description": "Express by creating p5.js generative art (.html + .js files)",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**Read** `templates/viewer.html` using the Read tool",
+      "description": "**Read** `templates/viewer.html` using the Read tool",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**Study** the exact structure, styling, and Anthropic branding",
+      "description": "**Study** the exact structure, styling, and Anthropic branding",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**Use that file as the LITERAL STARTING POINT** - not just inspiration",
+      "description": "**Use that file as the LITERAL STARTING POINT** - not just inspiration",
+      "type": "instruction"
+    },
+    {
+      "id": 6,
+      "name": "**Keep all FIXED sections exactly as shown** (header, sidebar structure, Anthropic colors/fonts, seed controls, action buttons)",
+      "description": "**Keep all FIXED sections exactly as shown** (header, sidebar structure, Anthropic colors/fonts, seed controls, action buttons)",
+      "type": "instruction"
+    },
+    {
+      "id": 7,
+      "name": "**Replace only the VARIABLE sections** marked in the file's comments (algorithm, parameters, UI controls for parameters)",
+      "description": "**Replace only the VARIABLE sections** marked in the file's comments (algorithm, parameters, UI controls for parameters)",
+      "type": "instruction"
+    },
+    {
+      "id": 8,
+      "name": "**Algorithmic Philosophy** - As markdown or text explaining the generative aesthetic",
+      "description": "**Algorithmic Philosophy** - As markdown or text explaining the generative aesthetic",
+      "type": "instruction"
+    },
+    {
+      "id": 9,
+      "name": "**Single HTML Artifact** - Self-contained interactive generative art built from `templates/viewer.html` (see STEP 0 and next section)",
+      "description": "**Single HTML Artifact** - Self-contained interactive generative art built from `templates/viewer.html` (see STEP 0 and next section)",
+      "type": "instruction"
+    },
+    {
+      "id": 10,
+      "name": "**In claude.ai**",
+      "description": "**In claude.ai**: Displayed as an interactive artifact - runs instantly",
+      "type": "instruction"
+    },
+    {
+      "id": 11,
+      "name": "**As a file**",
+      "description": "**As a file**: Save and open in any browser - no server needed",
+      "type": "instruction"
+    },
+    {
+      "id": 12,
+      "name": "**Sharing**",
+      "description": "**Sharing**: Send the HTML file - it's completely self-contained",
+      "type": "instruction"
+    },
+    {
+      "id": 13,
+      "name": "**Interpret the user's intent** - What aesthetic is being sought?",
+      "description": "**Interpret the user's intent** - What aesthetic is being sought?",
+      "type": "instruction"
+    },
+    {
+      "id": 14,
+      "name": "**Create an algorithmic philosophy** (4-6 paragraphs) describing the computational approach",
+      "description": "**Create an algorithmic philosophy** (4-6 paragraphs) describing the computational approach",
+      "type": "instruction"
+    },
+    {
+      "id": 15,
+      "name": "**Implement it in code** - Build the algorithm that expresses this philosophy",
+      "description": "**Implement it in code** - Build the algorithm that expresses this philosophy",
+      "type": "instruction"
+    },
+    {
+      "id": 16,
+      "name": "**Design appropriate parameters** - What should be tunable?",
+      "description": "**Design appropriate parameters** - What should be tunable?",
+      "type": "instruction"
+    },
+    {
+      "id": 17,
+      "name": "**Build matching UI controls** - Sliders/inputs for those parameters",
+      "description": "**Build matching UI controls** - Sliders/inputs for those parameters",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/brand-guidelines/manifest.json

@@ -0,0 +1,36 @@
+{
+  "name": "brand-guidelines",
+  "version": "1.0.0",
+  "description": "Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "brand-guidelines",
+      "name": "Anthropic Brand Styling",
+      "description": "Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "analyze",
+          "description": "Analyze requirements",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "execute",
+          "description": "Execute skill task",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "output",
+          "description": "Generate output",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/brand-guidelines/skills/brand-guidelines/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: brand-guidelines
+description: Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
+license: Complete terms in LICENSE.txt
+---
+
+# Anthropic Brand Styling
+
+## Overview
+
+To access Anthropic's official brand identity and style resources, use this skill.
+
+**Keywords**: branding, corporate identity, visual identity, post-processing, styling, brand colors, typography, Anthropic brand, visual formatting, visual design
+
+## Brand Guidelines
+
+### Colors
+
+**Main Colors:**
+
+- Dark: `#141413` - Primary text and dark backgrounds
+- Light: `#faf9f5` - Light backgrounds and text on dark
+- Mid Gray: `#b0aea5` - Secondary elements
+- Light Gray: `#e8e6dc` - Subtle backgrounds
+
+**Accent Colors:**
+
+- Orange: `#d97757` - Primary accent
+- Blue: `#6a9bcc` - Secondary accent
+- Green: `#788c5d` - Tertiary accent
+
+### Typography
+
+- **Headings**: Poppins (with Arial fallback)
+- **Body Text**: Lora (with Georgia fallback)
+- **Note**: Fonts should be pre-installed in your environment for best results
+
+## Features
+
+### Smart Font Application
+
+- Applies Poppins font to headings (24pt and larger)
+- Applies Lora font to body text
+- Automatically falls back to Arial/Georgia if custom fonts unavailable
+- Preserves readability across all systems
+
+### Text Styling
+
+- Headings (24pt+): Poppins font
+- Body text: Lora font
+- Smart color selection based on background
+- Preserves text hierarchy and formatting
+
+### Shape and Accent Colors
+
+- Non-text shapes use accent colors
+- Cycles through orange, blue, and green accents
+- Maintains visual interest while staying on-brand
+
+## Technical Details
+
+### Font Management
+
+- Uses system-installed Poppins and Lora fonts when available
+- Provides automatic fallback to Arial (headings) and Georgia (body)
+- No font installation required - works with existing system fonts
+- For best results, pre-install Poppins and Lora fonts in your environment
+
+### Color Application
+
+- Uses RGB color values for precise brand matching
+- Applied via python-pptx's RGBColor class
+- Maintains color fidelity across different systems

adapters-output/codebuddy/brand-guidelines/workflows/brand-guidelines.json

@@ -0,0 +1,27 @@
+{
+  "id": "brand-guidelines",
+  "name": "Anthropic Brand Styling",
+  "description": "Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "analyze",
+      "description": "Analyze requirements",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "execute",
+      "description": "Execute skill task",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "output",
+      "description": "Generate output",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/canvas-design/manifest.json

@@ -0,0 +1,30 @@
+{
+  "name": "canvas-design",
+  "version": "1.0.0",
+  "description": "Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "canvas-design",
+      "name": "canvas-design",
+      "description": "Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "Design Philosophy Creation (.md file)",
+          "description": "Design Philosophy Creation (.md file)",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "Express by creating it on a canvas (.pdf file or .png file)",
+          "description": "Express by creating it on a canvas (.pdf file or .png file)",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/canvas-design/skills/canvas-design/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: canvas-design
+description: Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.
+license: Complete terms in LICENSE.txt
+---
+
+These are instructions for creating design philosophies - aesthetic movements that are then EXPRESSED VISUALLY. Output only .md files, .pdf files, and .png files.
+
+Complete this in two steps:
+1. Design Philosophy Creation (.md file)
+2. Express by creating it on a canvas (.pdf file or .png file)
+
+First, undertake this task:
+
+## DESIGN PHILOSOPHY CREATION
+
+To begin, create a VISUAL PHILOSOPHY (not layouts or templates) that will be interpreted through:
+- Form, space, color, composition
+- Images, graphics, shapes, patterns
+- Minimal text as visual accent
+
+### THE CRITICAL UNDERSTANDING
+- What is received: Some subtle input or instructions by the user that should be taken into account, but used as a foundation; it should not constrain creative freedom.
+- What is created: A design philosophy/aesthetic movement.
+- What happens next: Then, the same version receives the philosophy and EXPRESSES IT VISUALLY - creating artifacts that are 90% visual design, 10% essential text.
+
+Consider this approach:
+- Write a manifesto for an art movement
+- The next phase involves making the artwork
+
+The philosophy must emphasize: Visual expression. Spatial communication. Artistic interpretation. Minimal words.
+
+### HOW TO GENERATE A VISUAL PHILOSOPHY
+
+**Name the movement** (1-2 words): "Brutalist Joy" / "Chromatic Silence" / "Metabolist Dreams"
+
+**Articulate the philosophy** (4-6 paragraphs - concise but complete):
+
+To capture the VISUAL essence, express how the philosophy manifests through:
+- Space and form
+- Color and material
+- Scale and rhythm
+- Composition and balance
+- Visual hierarchy
+
+**CRITICAL GUIDELINES:**
+- **Avoid redundancy**: Each design aspect should be mentioned once. Avoid repeating points about color theory, spatial relationships, or typographic principles unless adding new depth.
+- **Emphasize craftsmanship REPEATEDLY**: The philosophy MUST stress multiple times that the final work should appear as though it took countless hours to create, was labored over with care, and comes from someone at the absolute top of their field. This framing is essential - repeat phrases like "meticulously crafted," "the product of deep expertise," "painstaking attention," "master-level execution."
+- **Leave creative space**: Remain specific about the aesthetic direction, but concise enough that the next Claude has room to make interpretive choices also at a extremely high level of craftmanship.
+
+The philosophy must guide the next version to express ideas VISUALLY, not through text. Information lives in design, not paragraphs.
+
+### PHILOSOPHY EXAMPLES
+
+**"Concrete Poetry"**
+Philosophy: Communication through monumental form and bold geometry.
+Visual expression: Massive color blocks, sculptural typography (huge single words, tiny labels), Brutalist spatial divisions, Polish poster energy meets Le Corbusier. Ideas expressed through visual weight and spatial tension, not explanation. Text as rare, powerful gesture - never paragraphs, only essential words integrated into the visual architecture. Every element placed with the precision of a master craftsman.
+
+**"Chromatic Language"**
+Philosophy: Color as the primary information system.
+Visual expression: Geometric precision where color zones create meaning. Typography minimal - small sans-serif labels letting chromatic fields communicate. Think Josef Albers' interaction meets data visualization. Information encoded spatially and chromatically. Words only to anchor what color already shows. The result of painstaking chromatic calibration.
+
+**"Analog Meditation"**
+Philosophy: Quiet visual contemplation through texture and breathing room.
+Visual expression: Paper grain, ink bleeds, vast negative space. Photography and illustration dominate. Typography whispered (small, restrained, serving the visual). Japanese photobook aesthetic. Images breathe across pages. Text appears sparingly - short phrases, never explanatory blocks. Each composition balanced with the care of a meditation practice.
+
+**"Organic Systems"**
+Philosophy: Natural clustering and modular growth patterns.
+Visual expression: Rounded forms, organic arrangements, color from nature through architecture. Information shown through visual diagrams, spatial relationships, iconography. Text only for key labels floating in space. The composition tells the story through expert spatial orchestration.
+
+**"Geometric Silence"**
+Philosophy: Pure order and restraint.
+Visual expression: Grid-based precision, bold photography or stark graphics, dramatic negative space. Typography precise but minimal - small essential text, large quiet zones. Swiss formalism meets Brutalist material honesty. Structure communicates, not words. Every alignment the work of countless refinements.
+
+*These are condensed examples. The actual design philosophy should be 4-6 substantial paragraphs.*
+
+### ESSENTIAL PRINCIPLES
+- **VISUAL PHILOSOPHY**: Create an aesthetic worldview to be expressed through design
+- **MINIMAL TEXT**: Always emphasize that text is sparse, essential-only, integrated as visual element - never lengthy
+- **SPATIAL EXPRESSION**: Ideas communicate through space, form, color, composition - not paragraphs
+- **ARTISTIC FREEDOM**: The next Claude interprets the philosophy visually - provide creative room
+- **PURE DESIGN**: This is about making ART OBJECTS, not documents with decoration
+- **EXPERT CRAFTSMANSHIP**: Repeatedly emphasize the final work must look meticulously crafted, labored over with care, the product of countless hours by someone at the top of their field
+
+**The design philosophy should be 4-6 paragraphs long.** Fill it with poetic design philosophy that brings together the core vision. Avoid repeating the same points. Keep the design philosophy generic without mentioning the intention of the art, as if it can be used wherever. Output the design philosophy as a .md file.
+
+---
+
+## DEDUCING THE SUBTLE REFERENCE
+
+**CRITICAL STEP**: Before creating the canvas, identify the subtle conceptual thread from the original request.
+
+**THE ESSENTIAL PRINCIPLE**:
+The topic is a **subtle, niche reference embedded within the art itself** - not always literal, always sophisticated. Someone familiar with the subject should feel it intuitively, while others simply experience a masterful abstract composition. The design philosophy provides the aesthetic language. The deduced topic provides the soul - the quiet conceptual DNA woven invisibly into form, color, and composition.
+
+This is **VERY IMPORTANT**: The reference must be refined so it enhances the work's depth without announcing itself. Think like a jazz musician quoting another song - only those who know will catch it, but everyone appreciates the music.
+
+---
+
+## CANVAS CREATION
+
+With both the philosophy and the conceptual framework established, express it on a canvas. Take a moment to gather thoughts and clear the mind. Use the design philosophy created and the instructions below to craft a masterpiece, embodying all aspects of the philosophy with expert craftsmanship.
+
+**IMPORTANT**: For any type of content, even if the user requests something for a movie/game/book, the approach should still be sophisticated. Never lose sight of the idea that this should be art, not something that's cartoony or amateur.
+
+To create museum or magazine quality work, use the design philosophy as the foundation. Create one single page, highly visual, design-forward PDF or PNG output (unless asked for more pages). Generally use repeating patterns and perfect shapes. Treat the abstract philosophical design as if it were a scientific bible, borrowing the visual language of systematic observation—dense accumulation of marks, repeated elements, or layered patterns that build meaning through patient repetition and reward sustained viewing. Add sparse, clinical typography and systematic reference markers that suggest this could be a diagram from an imaginary discipline, treating the invisible subject with the same reverence typically reserved for documenting observable phenomena. Anchor the piece with simple phrase(s) or details positioned subtly, using a limited color palette that feels intentional and cohesive. Embrace the paradox of using analytical visual language to express ideas about human experience: the result should feel like an artifact that proves something ephemeral can be studied, mapped, and understood through careful attention. This is true art. 
+
+**Text as a contextual element**: Text is always minimal and visual-first, but let context guide whether that means whisper-quiet labels or bold typographic gestures. A punk venue poster might have larger, more aggressive type than a minimalist ceramics studio identity. Most of the time, font should be thin. All use of fonts must be design-forward and prioritize visual communication. Regardless of text scale, nothing falls off the page and nothing overlaps. Every element must be contained within the canvas boundaries with proper margins. Check carefully that all text, graphics, and visual elements have breathing room and clear separation. This is non-negotiable for professional execution. **IMPORTANT: Use different fonts if writing text. Search the `./canvas-fonts` directory. Regardless of approach, sophistication is non-negotiable.**
+
+Download and use whatever fonts are needed to make this a reality. Get creative by making the typography actually part of the art itself -- if the art is abstract, bring the font onto the canvas, not typeset digitally.
+
+To push boundaries, follow design instinct/intuition while using the philosophy as a guiding principle. Embrace ultimate design freedom and choice. Push aesthetics and design to the frontier. 
+
+**CRITICAL**: To achieve human-crafted quality (not AI-generated), create work that looks like it took countless hours. Make it appear as though someone at the absolute top of their field labored over every detail with painstaking care. Ensure the composition, spacing, color choices, typography - everything screams expert-level craftsmanship. Double-check that nothing overlaps, formatting is flawless, every detail perfect. Create something that could be shown to people to prove expertise and rank as undeniably impressive.
+
+Output the final result as a single, downloadable .pdf or .png file, alongside the design philosophy used as a .md file.
+
+---
+
+## FINAL STEP
+
+**IMPORTANT**: The user ALREADY said "It isn't perfect enough. It must be pristine, a masterpiece if craftsmanship, as if it were about to be displayed in a museum."
+
+**CRITICAL**: To refine the work, avoid adding more graphics; instead refine what has been created and make it extremely crisp, respecting the design philosophy and the principles of minimalism entirely. Rather than adding a fun filter or refactoring a font, consider how to make the existing composition more cohesive with the art. If the instinct is to call a new function or draw a new shape, STOP and instead ask: "How can I make what's already here more of a piece of art?"
+
+Take a second pass. Go back to the code and refine/polish further to make this a philosophically designed masterpiece.
+
+## MULTI-PAGE OPTION
+
+To create additional pages when requested, create more creative pages along the same lines as the design philosophy but distinctly different as well. Bundle those pages in the same .pdf or many .pngs. Treat the first page as just a single page in a whole coffee table book waiting to be filled. Make the next pages unique twists and memories of the original. Have them almost tell a story in a very tasteful way. Exercise full creative freedom.

adapters-output/codebuddy/canvas-design/workflows/canvas-design.json

@@ -0,0 +1,21 @@
+{
+  "id": "canvas-design",
+  "name": "canvas-design",
+  "description": "Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "Design Philosophy Creation (.md file)",
+      "description": "Design Philosophy Creation (.md file)",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "Express by creating it on a canvas (.pdf file or .png file)",
+      "description": "Express by creating it on a canvas (.pdf file or .png file)",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/code-generator/manifest.json

@@ -0,0 +1,48 @@
+{
+  "name": "code-generator",
+  "version": "1.0.0",
+  "description": "帮助生成高质量的代码，包括函数、类、模块和完整项目。支持多种编程语言，遵循最佳实践和设计模式。适用于快速开发、代码示例生成或教学演示。",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "code-generator",
+      "name": "代码生成技能",
+      "description": "帮助生成高质量的代码，包括函数、类、模块和完整项目。支持多种编程语言，遵循最佳实践和设计模式。适用于快速开发、代码示例生成或教学演示。",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**清晰性**",
+          "description": "**清晰性**: 代码应清晰易懂，命名规范",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**可维护性**",
+          "description": "**可维护性**: 结构良好，易于修改和扩展",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**健壮性**",
+          "description": "**健壮性**: 包含错误处理和边界检查",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**文档化**",
+          "description": "**文档化**: 提供完整的注释和文档",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**测试性**",
+          "description": "**测试性**: 代码应易于测试",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/code-generator/skills/code-generator/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: code-generator
+description: 帮助生成高质量的代码，包括函数、类、模块和完整项目。支持多种编程语言，遵循最佳实践和设计模式。适用于快速开发、代码示例生成或教学演示。
+---
+
+# 代码生成技能
+
+## 概述
+
+本技能帮助您生成高质量的代码，支持多种编程语言，遵循最佳实践和设计模式。
+
+**关键词**: 代码生成、编程、函数、类、模块、项目开发、代码示例
+
+## 核心功能
+
+### 1. 函数和类生成
+
+- 生成符合规范的函数和类
+- 添加完整的文档注释
+- 实现错误处理和边界检查
+- 遵循语言特定的最佳实践
+
+### 2. 模块和包开发
+
+- 创建结构化的模块和包
+- 设计清晰的 API 接口
+- 实现模块间的依赖管理
+- 创建配置文件和初始化代码
+
+### 3. 项目脚手架
+
+- 生成完整的项目结构
+- 创建配置文件（package.json, requirements.txt 等）
+- 设置构建和测试环境
+- 添加 README 和文档
+
+### 4. 代码优化和重构
+
+- 优化代码性能和可读性
+- 应用设计模式和最佳实践
+- 重构代码结构
+- 添加单元测试
+
+## 使用指南
+
+### 代码生成原则
+
+1. **清晰性**: 代码应清晰易懂，命名规范
+2. **可维护性**: 结构良好，易于修改和扩展
+3. **健壮性**: 包含错误处理和边界检查
+4. **文档化**: 提供完整的注释和文档
+5. **测试性**: 代码应易于测试
+
+### 支持的编程语言
+
+- Python
+- JavaScript/TypeScript
+- Java
+- Go
+- Rust
+- 其他常见编程语言
+
+### 代码结构要求
+
+- **导入部分**: 清晰的导入语句
+- **文档字符串**: 函数和类的文档
+- **实现代码**: 核心逻辑实现
+- **测试代码**: 单元测试（如需要）
+- **示例代码**: 使用示例（如需要）
+
+## 输出格式
+
+生成的代码应包含：
+
+- **代码文件**: 完整的源代码文件
+- **文档注释**: 函数、类、模块的文档
+- **使用示例**: 代码使用示例
+- **依赖说明**: 所需的依赖和版本
+- **测试代码**: 相关的测试用例
+
+## 最佳实践
+
+- 遵循语言的编码规范和风格指南
+- 使用有意义的变量和函数名
+- 添加类型提示（如适用）
+- 实现适当的错误处理
+- 编写清晰的文档注释
+- 考虑性能和可扩展性
+- 遵循 SOLID 原则和设计模式

adapters-output/codebuddy/code-generator/workflows/code-generator.json

@@ -0,0 +1,39 @@
+{
+  "id": "code-generator",
+  "name": "代码生成技能",
+  "description": "帮助生成高质量的代码，包括函数、类、模块和完整项目。支持多种编程语言，遵循最佳实践和设计模式。适用于快速开发、代码示例生成或教学演示。",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**清晰性**",
+      "description": "**清晰性**: 代码应清晰易懂，命名规范",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**可维护性**",
+      "description": "**可维护性**: 结构良好，易于修改和扩展",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**健壮性**",
+      "description": "**健壮性**: 包含错误处理和边界检查",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**文档化**",
+      "description": "**文档化**: 提供完整的注释和文档",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**测试性**",
+      "description": "**测试性**: 代码应易于测试",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/course-designer/manifest.json

@@ -0,0 +1,42 @@
+{
+  "name": "course-designer",
+  "version": "1.0.0",
+  "description": "帮助设计和规划课程内容，包括课程大纲、学习目标、教学计划和评估方案。适用于教育工作者、培训师或需要创建结构化学习内容的场景。",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "course-designer",
+      "name": "课程设计技能",
+      "description": "帮助设计和规划课程内容，包括课程大纲、学习目标、教学计划和评估方案。适用于教育工作者、培训师或需要创建结构化学习内容的场景。",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**需求分析**",
+          "description": "**需求分析**",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**内容规划**",
+          "description": "**内容规划**",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**活动设计**",
+          "description": "**活动设计**",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**评估设计**",
+          "description": "**评估设计**",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/course-designer/skills/course-designer/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: course-designer
+description: 帮助设计和规划课程内容，包括课程大纲、学习目标、教学计划和评估方案。适用于教育工作者、培训师或需要创建结构化学习内容的场景。
+---
+
+# 课程设计技能
+
+## 概述
+
+本技能帮助您创建结构化的课程内容，包括课程大纲、学习目标、教学计划和评估方案。
+
+**关键词**: 课程设计、教学大纲、学习目标、教学计划、课程规划、教育设计
+
+## 核心功能
+
+### 1. 课程大纲设计
+
+- 分析学习需求和目标受众
+- 设计课程结构和模块划分
+- 确定课程时长和进度安排
+- 规划知识点的递进关系
+
+### 2. 学习目标制定
+
+- 使用 Bloom 分类法制定认知目标
+- 设计可测量的学习成果
+- 确保目标与评估方式对齐
+- 区分不同层次的学习目标（记忆、理解、应用、分析、评价、创造）
+
+### 3. 教学计划编写
+
+- 设计每节课的教学流程
+- 规划教学活动和互动环节
+- 准备教学资源和材料清单
+- 安排实践练习和作业
+
+### 4. 评估方案设计
+
+- 设计形成性评估（过程评估）
+- 设计总结性评估（最终评估）
+- 创建评估标准和评分 rubric
+- 规划多种评估方式（测验、项目、报告等）
+
+## 使用指南
+
+### 课程设计流程
+
+1. **需求分析**
+   - 明确目标受众和学习需求
+   - 确定课程目标和预期成果
+   - 分析现有资源和约束条件
+
+2. **内容规划**
+   - 划分课程模块和单元
+   - 确定每个模块的核心知识点
+   - 规划知识点的学习顺序
+
+3. **活动设计**
+   - 为每个知识点设计教学活动
+   - 规划实践练习和项目
+   - 设计互动和讨论环节
+
+4. **评估设计**
+   - 设计评估方式和标准
+   - 创建评估工具和 rubric
+   - 规划评估时间点
+
+## 输出格式
+
+课程设计应包含以下部分：
+
+- **课程基本信息**: 课程名称、目标受众、总时长
+- **课程目标**: 总体目标和具体学习目标
+- **课程大纲**: 模块划分和内容概览
+- **详细教学计划**: 每节课的教学安排
+- **评估方案**: 评估方式和标准
+- **资源清单**: 所需的教学资源
+
+## 最佳实践
+
+- 确保学习目标清晰、可测量
+- 保持内容递进，由浅入深
+- 平衡理论学习和实践应用
+- 设计多样化的教学活动
+- 评估方式应与学习目标对齐
+- 考虑不同学习风格和需求

adapters-output/codebuddy/course-designer/workflows/course-designer.json

@@ -0,0 +1,33 @@
+{
+  "id": "course-designer",
+  "name": "课程设计技能",
+  "description": "帮助设计和规划课程内容，包括课程大纲、学习目标、教学计划和评估方案。适用于教育工作者、培训师或需要创建结构化学习内容的场景。",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**需求分析**",
+      "description": "**需求分析**",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**内容规划**",
+      "description": "**内容规划**",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**活动设计**",
+      "description": "**活动设计**",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**评估设计**",
+      "description": "**评估设计**",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/doc-coauthoring/manifest.json

@@ -0,0 +1,132 @@
+{
+  "name": "doc-coauthoring",
+  "version": "1.0.0",
+  "description": "Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "doc-coauthoring",
+      "name": "Doc Co-Authoring Workflow",
+      "description": "Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**Context Gathering**",
+          "description": "**Context Gathering**: User provides all relevant context while Claude asks clarifying questions",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**Refinement & Structure**",
+          "description": "**Refinement & Structure**: Iteratively build each section through brainstorming and editing",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**Reader Testing**",
+          "description": "**Reader Testing**: Test the doc with a fresh Claude (no context) to catch blind spots before others read it",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "What type of document is this? (e.g., technical spec, decision doc, proposal)",
+          "description": "What type of document is this? (e.g., technical spec, decision doc, proposal)",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "Who's the primary audience?",
+          "description": "Who's the primary audience?",
+          "type": "instruction"
+        },
+        {
+          "id": 6,
+          "name": "What's the desired impact when someone reads this?",
+          "description": "What's the desired impact when someone reads this?",
+          "type": "instruction"
+        },
+        {
+          "id": 7,
+          "name": "Is there a template or specific format to follow?",
+          "description": "Is there a template or specific format to follow?",
+          "type": "instruction"
+        },
+        {
+          "id": 8,
+          "name": "Any other constraints or context to know?",
+          "description": "Any other constraints or context to know?",
+          "type": "instruction"
+        },
+        {
+          "id": 9,
+          "name": "Clarifying questions will be asked about what to include",
+          "description": "Clarifying questions will be asked about what to include",
+          "type": "instruction"
+        },
+        {
+          "id": 10,
+          "name": "5-20 options will be brainstormed",
+          "description": "5-20 options will be brainstormed",
+          "type": "instruction"
+        },
+        {
+          "id": 11,
+          "name": "User will indicate what to keep/remove/combine",
+          "description": "User will indicate what to keep/remove/combine",
+          "type": "instruction"
+        },
+        {
+          "id": 12,
+          "name": "The section will be drafted",
+          "description": "The section will be drafted",
+          "type": "instruction"
+        },
+        {
+          "id": 13,
+          "name": "It will be refined through surgical edits",
+          "description": "It will be refined through surgical edits",
+          "type": "instruction"
+        },
+        {
+          "id": 14,
+          "name": "Open a fresh Claude conversation",
+          "description": "Open a fresh Claude conversation: https://claude.ai",
+          "type": "instruction"
+        },
+        {
+          "id": 15,
+          "name": "Paste or share the document content (if using a shared doc platform with connectors enabled, provide the link)",
+          "description": "Paste or share the document content (if using a shared doc platform with connectors enabled, provide the link)",
+          "type": "instruction"
+        },
+        {
+          "id": 16,
+          "name": "Ask Reader Claude the generated questions",
+          "description": "Ask Reader Claude the generated questions",
+          "type": "instruction"
+        },
+        {
+          "id": 17,
+          "name": "Recommend they do a final read-through themselves - they own this document and are responsible for its quality",
+          "description": "Recommend they do a final read-through themselves - they own this document and are responsible for its quality",
+          "type": "instruction"
+        },
+        {
+          "id": 18,
+          "name": "Suggest double-checking any facts, links, or technical details",
+          "description": "Suggest double-checking any facts, links, or technical details",
+          "type": "instruction"
+        },
+        {
+          "id": 19,
+          "name": "Ask them to verify it achieves the impact they wanted",
+          "description": "Ask them to verify it achieves the impact they wanted",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/doc-coauthoring/skills/doc-coauthoring/SKILL.md

@@ -0,0 +1,375 @@
+---
+name: doc-coauthoring
+description: Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.
+---
+
+# Doc Co-Authoring Workflow
+
+This skill provides a structured workflow for guiding users through collaborative document creation. Act as an active guide, walking users through three stages: Context Gathering, Refinement & Structure, and Reader Testing.
+
+## When to Offer This Workflow
+
+**Trigger conditions:**
+- User mentions writing documentation: "write a doc", "draft a proposal", "create a spec", "write up"
+- User mentions specific doc types: "PRD", "design doc", "decision doc", "RFC"
+- User seems to be starting a substantial writing task
+
+**Initial offer:**
+Offer the user a structured workflow for co-authoring the document. Explain the three stages:
+
+1. **Context Gathering**: User provides all relevant context while Claude asks clarifying questions
+2. **Refinement & Structure**: Iteratively build each section through brainstorming and editing
+3. **Reader Testing**: Test the doc with a fresh Claude (no context) to catch blind spots before others read it
+
+Explain that this approach helps ensure the doc works well when others read it (including when they paste it into Claude). Ask if they want to try this workflow or prefer to work freeform.
+
+If user declines, work freeform. If user accepts, proceed to Stage 1.
+
+## Stage 1: Context Gathering
+
+**Goal:** Close the gap between what the user knows and what Claude knows, enabling smart guidance later.
+
+### Initial Questions
+
+Start by asking the user for meta-context about the document:
+
+1. What type of document is this? (e.g., technical spec, decision doc, proposal)
+2. Who's the primary audience?
+3. What's the desired impact when someone reads this?
+4. Is there a template or specific format to follow?
+5. Any other constraints or context to know?
+
+Inform them they can answer in shorthand or dump information however works best for them.
+
+**If user provides a template or mentions a doc type:**
+- Ask if they have a template document to share
+- If they provide a link to a shared document, use the appropriate integration to fetch it
+- If they provide a file, read it
+
+**If user mentions editing an existing shared document:**
+- Use the appropriate integration to read the current state
+- Check for images without alt-text
+- If images exist without alt-text, explain that when others use Claude to understand the doc, Claude won't be able to see them. Ask if they want alt-text generated. If so, request they paste each image into chat for descriptive alt-text generation.
+
+### Info Dumping
+
+Once initial questions are answered, encourage the user to dump all the context they have. Request information such as:
+- Background on the project/problem
+- Related team discussions or shared documents
+- Why alternative solutions aren't being used
+- Organizational context (team dynamics, past incidents, politics)
+- Timeline pressures or constraints
+- Technical architecture or dependencies
+- Stakeholder concerns
+
+Advise them not to worry about organizing it - just get it all out. Offer multiple ways to provide context:
+- Info dump stream-of-consciousness
+- Point to team channels or threads to read
+- Link to shared documents
+
+**If integrations are available** (e.g., Slack, Teams, Google Drive, SharePoint, or other MCP servers), mention that these can be used to pull in context directly.
+
+**If no integrations are detected and in Claude.ai or Claude app:** Suggest they can enable connectors in their Claude settings to allow pulling context from messaging apps and document storage directly.
+
+Inform them clarifying questions will be asked once they've done their initial dump.
+
+**During context gathering:**
+
+- If user mentions team channels or shared documents:
+  - If integrations available: Inform them the content will be read now, then use the appropriate integration
+  - If integrations not available: Explain lack of access. Suggest they enable connectors in Claude settings, or paste the relevant content directly.
+
+- If user mentions entities/projects that are unknown:
+  - Ask if connected tools should be searched to learn more
+  - Wait for user confirmation before searching
+
+- As user provides context, track what's being learned and what's still unclear
+
+**Asking clarifying questions:**
+
+When user signals they've done their initial dump (or after substantial context provided), ask clarifying questions to ensure understanding:
+
+Generate 5-10 numbered questions based on gaps in the context.
+
+Inform them they can use shorthand to answer (e.g., "1: yes, 2: see #channel, 3: no because backwards compat"), link to more docs, point to channels to read, or just keep info-dumping. Whatever's most efficient for them.
+
+**Exit condition:**
+Sufficient context has been gathered when questions show understanding - when edge cases and trade-offs can be asked about without needing basics explained.
+
+**Transition:**
+Ask if there's any more context they want to provide at this stage, or if it's time to move on to drafting the document.
+
+If user wants to add more, let them. When ready, proceed to Stage 2.
+
+## Stage 2: Refinement & Structure
+
+**Goal:** Build the document section by section through brainstorming, curation, and iterative refinement.
+
+**Instructions to user:**
+Explain that the document will be built section by section. For each section:
+1. Clarifying questions will be asked about what to include
+2. 5-20 options will be brainstormed
+3. User will indicate what to keep/remove/combine
+4. The section will be drafted
+5. It will be refined through surgical edits
+
+Start with whichever section has the most unknowns (usually the core decision/proposal), then work through the rest.
+
+**Section ordering:**
+
+If the document structure is clear:
+Ask which section they'd like to start with.
+
+Suggest starting with whichever section has the most unknowns. For decision docs, that's usually the core proposal. For specs, it's typically the technical approach. Summary sections are best left for last.
+
+If user doesn't know what sections they need:
+Based on the type of document and template, suggest 3-5 sections appropriate for the doc type.
+
+Ask if this structure works, or if they want to adjust it.
+
+**Once structure is agreed:**
+
+Create the initial document structure with placeholder text for all sections.
+
+**If access to artifacts is available:**
+Use `create_file` to create an artifact. This gives both Claude and the user a scaffold to work from.
+
+Inform them that the initial structure with placeholders for all sections will be created.
+
+Create artifact with all section headers and brief placeholder text like "[To be written]" or "[Content here]".
+
+Provide the scaffold link and indicate it's time to fill in each section.
+
+**If no access to artifacts:**
+Create a markdown file in the working directory. Name it appropriately (e.g., `decision-doc.md`, `technical-spec.md`).
+
+Inform them that the initial structure with placeholders for all sections will be created.
+
+Create file with all section headers and placeholder text.
+
+Confirm the filename has been created and indicate it's time to fill in each section.
+
+**For each section:**
+
+### Step 1: Clarifying Questions
+
+Announce work will begin on the [SECTION NAME] section. Ask 5-10 clarifying questions about what should be included:
+
+Generate 5-10 specific questions based on context and section purpose.
+
+Inform them they can answer in shorthand or just indicate what's important to cover.
+
+### Step 2: Brainstorming
+
+For the [SECTION NAME] section, brainstorm [5-20] things that might be included, depending on the section's complexity. Look for:
+- Context shared that might have been forgotten
+- Angles or considerations not yet mentioned
+
+Generate 5-20 numbered options based on section complexity. At the end, offer to brainstorm more if they want additional options.
+
+### Step 3: Curation
+
+Ask which points should be kept, removed, or combined. Request brief justifications to help learn priorities for the next sections.
+
+Provide examples:
+- "Keep 1,4,7,9"
+- "Remove 3 (duplicates 1)"
+- "Remove 6 (audience already knows this)"
+- "Combine 11 and 12"
+
+**If user gives freeform feedback** (e.g., "looks good" or "I like most of it but...") instead of numbered selections, extract their preferences and proceed. Parse what they want kept/removed/changed and apply it.
+
+### Step 4: Gap Check
+
+Based on what they've selected, ask if there's anything important missing for the [SECTION NAME] section.
+
+### Step 5: Drafting
+
+Use `str_replace` to replace the placeholder text for this section with the actual drafted content.
+
+Announce the [SECTION NAME] section will be drafted now based on what they've selected.
+
+**If using artifacts:**
+After drafting, provide a link to the artifact.
+
+Ask them to read through it and indicate what to change. Note that being specific helps learning for the next sections.
+
+**If using a file (no artifacts):**
+After drafting, confirm completion.
+
+Inform them the [SECTION NAME] section has been drafted in [filename]. Ask them to read through it and indicate what to change. Note that being specific helps learning for the next sections.
+
+**Key instruction for user (include when drafting the first section):**
+Provide a note: Instead of editing the doc directly, ask them to indicate what to change. This helps learning of their style for future sections. For example: "Remove the X bullet - already covered by Y" or "Make the third paragraph more concise".
+
+### Step 6: Iterative Refinement
+
+As user provides feedback:
+- Use `str_replace` to make edits (never reprint the whole doc)
+- **If using artifacts:** Provide link to artifact after each edit
+- **If using files:** Just confirm edits are complete
+- If user edits doc directly and asks to read it: mentally note the changes they made and keep them in mind for future sections (this shows their preferences)
+
+**Continue iterating** until user is satisfied with the section.
+
+### Quality Checking
+
+After 3 consecutive iterations with no substantial changes, ask if anything can be removed without losing important information.
+
+When section is done, confirm [SECTION NAME] is complete. Ask if ready to move to the next section.
+
+**Repeat for all sections.**
+
+### Near Completion
+
+As approaching completion (80%+ of sections done), announce intention to re-read the entire document and check for:
+- Flow and consistency across sections
+- Redundancy or contradictions
+- Anything that feels like "slop" or generic filler
+- Whether every sentence carries weight
+
+Read entire document and provide feedback.
+
+**When all sections are drafted and refined:**
+Announce all sections are drafted. Indicate intention to review the complete document one more time.
+
+Review for overall coherence, flow, completeness.
+
+Provide any final suggestions.
+
+Ask if ready to move to Reader Testing, or if they want to refine anything else.
+
+## Stage 3: Reader Testing
+
+**Goal:** Test the document with a fresh Claude (no context bleed) to verify it works for readers.
+
+**Instructions to user:**
+Explain that testing will now occur to see if the document actually works for readers. This catches blind spots - things that make sense to the authors but might confuse others.
+
+### Testing Approach
+
+**If access to sub-agents is available (e.g., in Claude Code):**
+
+Perform the testing directly without user involvement.
+
+### Step 1: Predict Reader Questions
+
+Announce intention to predict what questions readers might ask when trying to discover this document.
+
+Generate 5-10 questions that readers would realistically ask.
+
+### Step 2: Test with Sub-Agent
+
+Announce that these questions will be tested with a fresh Claude instance (no context from this conversation).
+
+For each question, invoke a sub-agent with just the document content and the question.
+
+Summarize what Reader Claude got right/wrong for each question.
+
+### Step 3: Run Additional Checks
+
+Announce additional checks will be performed.
+
+Invoke sub-agent to check for ambiguity, false assumptions, contradictions.
+
+Summarize any issues found.
+
+### Step 4: Report and Fix
+
+If issues found:
+Report that Reader Claude struggled with specific issues.
+
+List the specific issues.
+
+Indicate intention to fix these gaps.
+
+Loop back to refinement for problematic sections.
+
+---
+
+**If no access to sub-agents (e.g., claude.ai web interface):**
+
+The user will need to do the testing manually.
+
+### Step 1: Predict Reader Questions
+
+Ask what questions people might ask when trying to discover this document. What would they type into Claude.ai?
+
+Generate 5-10 questions that readers would realistically ask.
+
+### Step 2: Setup Testing
+
+Provide testing instructions:
+1. Open a fresh Claude conversation: https://claude.ai
+2. Paste or share the document content (if using a shared doc platform with connectors enabled, provide the link)
+3. Ask Reader Claude the generated questions
+
+For each question, instruct Reader Claude to provide:
+- The answer
+- Whether anything was ambiguous or unclear
+- What knowledge/context the doc assumes is already known
+
+Check if Reader Claude gives correct answers or misinterprets anything.
+
+### Step 3: Additional Checks
+
+Also ask Reader Claude:
+- "What in this doc might be ambiguous or unclear to readers?"
+- "What knowledge or context does this doc assume readers already have?"
+- "Are there any internal contradictions or inconsistencies?"
+
+### Step 4: Iterate Based on Results
+
+Ask what Reader Claude got wrong or struggled with. Indicate intention to fix those gaps.
+
+Loop back to refinement for any problematic sections.
+
+---
+
+### Exit Condition (Both Approaches)
+
+When Reader Claude consistently answers questions correctly and doesn't surface new gaps or ambiguities, the doc is ready.
+
+## Final Review
+
+When Reader Testing passes:
+Announce the doc has passed Reader Claude testing. Before completion:
+
+1. Recommend they do a final read-through themselves - they own this document and are responsible for its quality
+2. Suggest double-checking any facts, links, or technical details
+3. Ask them to verify it achieves the impact they wanted
+
+Ask if they want one more review, or if the work is done.
+
+**If user wants final review, provide it. Otherwise:**
+Announce document completion. Provide a few final tips:
+- Consider linking this conversation in an appendix so readers can see how the doc was developed
+- Use appendices to provide depth without bloating the main doc
+- Update the doc as feedback is received from real readers
+
+## Tips for Effective Guidance
+
+**Tone:**
+- Be direct and procedural
+- Explain rationale briefly when it affects user behavior
+- Don't try to "sell" the approach - just execute it
+
+**Handling Deviations:**
+- If user wants to skip a stage: Ask if they want to skip this and write freeform
+- If user seems frustrated: Acknowledge this is taking longer than expected. Suggest ways to move faster
+- Always give user agency to adjust the process
+
+**Context Management:**
+- Throughout, if context is missing on something mentioned, proactively ask
+- Don't let gaps accumulate - address them as they come up
+
+**Artifact Management:**
+- Use `create_file` for drafting full sections
+- Use `str_replace` for all edits
+- Provide artifact link after every change
+- Never use artifacts for brainstorming lists - that's just conversation
+
+**Quality over Speed:**
+- Don't rush through stages
+- Each iteration should make meaningful improvements
+- The goal is a document that actually works for readers

adapters-output/codebuddy/doc-coauthoring/workflows/doc-coauthoring.json

@@ -0,0 +1,123 @@
+{
+  "id": "doc-coauthoring",
+  "name": "Doc Co-Authoring Workflow",
+  "description": "Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**Context Gathering**",
+      "description": "**Context Gathering**: User provides all relevant context while Claude asks clarifying questions",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**Refinement & Structure**",
+      "description": "**Refinement & Structure**: Iteratively build each section through brainstorming and editing",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**Reader Testing**",
+      "description": "**Reader Testing**: Test the doc with a fresh Claude (no context) to catch blind spots before others read it",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "What type of document is this? (e.g., technical spec, decision doc, proposal)",
+      "description": "What type of document is this? (e.g., technical spec, decision doc, proposal)",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "Who's the primary audience?",
+      "description": "Who's the primary audience?",
+      "type": "instruction"
+    },
+    {
+      "id": 6,
+      "name": "What's the desired impact when someone reads this?",
+      "description": "What's the desired impact when someone reads this?",
+      "type": "instruction"
+    },
+    {
+      "id": 7,
+      "name": "Is there a template or specific format to follow?",
+      "description": "Is there a template or specific format to follow?",
+      "type": "instruction"
+    },
+    {
+      "id": 8,
+      "name": "Any other constraints or context to know?",
+      "description": "Any other constraints or context to know?",
+      "type": "instruction"
+    },
+    {
+      "id": 9,
+      "name": "Clarifying questions will be asked about what to include",
+      "description": "Clarifying questions will be asked about what to include",
+      "type": "instruction"
+    },
+    {
+      "id": 10,
+      "name": "5-20 options will be brainstormed",
+      "description": "5-20 options will be brainstormed",
+      "type": "instruction"
+    },
+    {
+      "id": 11,
+      "name": "User will indicate what to keep/remove/combine",
+      "description": "User will indicate what to keep/remove/combine",
+      "type": "instruction"
+    },
+    {
+      "id": 12,
+      "name": "The section will be drafted",
+      "description": "The section will be drafted",
+      "type": "instruction"
+    },
+    {
+      "id": 13,
+      "name": "It will be refined through surgical edits",
+      "description": "It will be refined through surgical edits",
+      "type": "instruction"
+    },
+    {
+      "id": 14,
+      "name": "Open a fresh Claude conversation",
+      "description": "Open a fresh Claude conversation: https://claude.ai",
+      "type": "instruction"
+    },
+    {
+      "id": 15,
+      "name": "Paste or share the document content (if using a shared doc platform with connectors enabled, provide the link)",
+      "description": "Paste or share the document content (if using a shared doc platform with connectors enabled, provide the link)",
+      "type": "instruction"
+    },
+    {
+      "id": 16,
+      "name": "Ask Reader Claude the generated questions",
+      "description": "Ask Reader Claude the generated questions",
+      "type": "instruction"
+    },
+    {
+      "id": 17,
+      "name": "Recommend they do a final read-through themselves - they own this document and are responsible for its quality",
+      "description": "Recommend they do a final read-through themselves - they own this document and are responsible for its quality",
+      "type": "instruction"
+    },
+    {
+      "id": 18,
+      "name": "Suggest double-checking any facts, links, or technical details",
+      "description": "Suggest double-checking any facts, links, or technical details",
+      "type": "instruction"
+    },
+    {
+      "id": 19,
+      "name": "Ask them to verify it achieves the impact they wanted",
+      "description": "Ask them to verify it achieves the impact they wanted",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/documentation-builder/manifest.json

@@ -0,0 +1,48 @@
+{
+  "name": "documentation-builder",
+  "version": "1.0.0",
+  "description": "帮助生成技术文档，包括 API 文档、用户手册、开发指南、README 等。支持多种文档格式，确保文档清晰、完整、易于理解。",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "documentation-builder",
+      "name": "文档构建技能",
+      "description": "帮助生成技术文档，包括 API 文档、用户手册、开发指南、README 等。支持多种文档格式，确保文档清晰、完整、易于理解。",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**清晰性**",
+          "description": "**清晰性**: 文档应清晰易懂，避免歧义",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**完整性**",
+          "description": "**完整性**: 覆盖所有重要功能和场景",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**准确性**",
+          "description": "**准确性**: 确保文档与代码一致",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**实用性**",
+          "description": "**实用性**: 提供实际可用的示例",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**可维护性**",
+          "description": "**可维护性**: 文档应易于更新和维护",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/documentation-builder/skills/documentation-builder/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: documentation-builder
+description: 帮助生成技术文档，包括 API 文档、用户手册、开发指南、README 等。支持多种文档格式，确保文档清晰、完整、易于理解。
+---
+
+# 文档构建技能
+
+## 概述
+
+本技能帮助您生成各种技术文档，包括 API 文档、用户手册、开发指南等。
+
+**关键词**: 文档编写、API 文档、用户手册、开发指南、技术文档、README
+
+## 核心功能
+
+### 1. API 文档生成
+
+- 生成 RESTful API 文档
+- 描述 API 端点、参数和响应
+- 提供请求和响应示例
+- 创建交互式 API 文档（如 Swagger/OpenAPI）
+
+### 2. 用户手册编写
+
+- 编写用户使用指南
+- 创建快速入门教程
+- 提供常见问题解答（FAQ）
+- 设计操作步骤和截图
+
+### 3. 开发指南创建
+
+- 编写开发环境搭建指南
+- 创建代码贡献指南
+- 设计架构和设计文档
+- 提供开发最佳实践
+
+### 4. README 和项目文档
+
+- 生成项目 README
+- 创建安装和使用说明
+- 编写变更日志（CHANGELOG）
+- 设计项目结构说明
+
+## 使用指南
+
+### 文档编写原则
+
+1. **清晰性**: 文档应清晰易懂，避免歧义
+2. **完整性**: 覆盖所有重要功能和场景
+3. **准确性**: 确保文档与代码一致
+4. **实用性**: 提供实际可用的示例
+5. **可维护性**: 文档应易于更新和维护
+
+### 文档结构
+
+- **概述**: 项目或功能的概述
+- **快速开始**: 快速上手指南
+- **详细说明**: 详细的功能说明
+- **API 参考**: API 接口文档（如适用）
+- **示例**: 使用示例和代码示例
+- **常见问题**: FAQ 和故障排除
+
+### 文档格式
+
+- Markdown（.md）
+- reStructuredText（.rst）
+- HTML
+- PDF（如需要）
+
+## 输出格式
+
+文档应包含：
+
+- **文档文件**: 完整的文档内容
+- **目录结构**: 清晰的章节和目录
+- **代码示例**: 实际可运行的代码示例
+- **图表和截图**: 可视化说明（如需要）
+- **链接和引用**: 相关资源的链接
+
+## 最佳实践
+
+- 使用清晰的标题和章节结构
+- 提供实际可用的代码示例
+- 保持文档与代码同步更新
+- 使用图表和截图辅助说明
+- 编写易于搜索的文档
+- 考虑不同水平的读者
+- 定期审查和更新文档

adapters-output/codebuddy/documentation-builder/workflows/documentation-builder.json

@@ -0,0 +1,39 @@
+{
+  "id": "documentation-builder",
+  "name": "文档构建技能",
+  "description": "帮助生成技术文档，包括 API 文档、用户手册、开发指南、README 等。支持多种文档格式，确保文档清晰、完整、易于理解。",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**清晰性**",
+      "description": "**清晰性**: 文档应清晰易懂，避免歧义",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**完整性**",
+      "description": "**完整性**: 覆盖所有重要功能和场景",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**准确性**",
+      "description": "**准确性**: 确保文档与代码一致",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**实用性**",
+      "description": "**实用性**: 提供实际可用的示例",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**可维护性**",
+      "description": "**可维护性**: 文档应易于更新和维护",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/docx/manifest.json

@@ -0,0 +1,108 @@
+{
+  "name": "docx",
+  "version": "1.0.0",
+  "description": "Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "docx",
+      "name": "DOCX creation, editing, and analysis",
+      "description": "Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**MANDATORY - READ ENTIRE FILE**",
+          "description": "**MANDATORY - READ ENTIRE FILE**: Read [`docx-js.md`](docx-js.md) (~500 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for detailed syntax, critical formatting rules, and best practices before proceeding with document creation.",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "Create a JavaScript/TypeScript file using Document, Paragraph, TextRun components (You can assume all dependencies are installed, but if not, refer to the dependencies section below)",
+          "description": "Create a JavaScript/TypeScript file using Document, Paragraph, TextRun components (You can assume all dependencies are installed, but if not, refer to the dependencies section below)",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "Export as .docx using Packer.toBuffer()",
+          "description": "Export as .docx using Packer.toBuffer()",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**MANDATORY - READ ENTIRE FILE**",
+          "description": "**MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for the Document library API and XML patterns for directly editing document files.",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "Unpack the document",
+          "description": "Unpack the document: `python ooxml/scripts/unpack.py <office_file> <output_directory>`",
+          "type": "instruction"
+        },
+        {
+          "id": 6,
+          "name": "Create and run a Python script using the Document library (see \"Document Library\" section in ooxml.md)",
+          "description": "Create and run a Python script using the Document library (see \"Document Library\" section in ooxml.md)",
+          "type": "instruction"
+        },
+        {
+          "id": 7,
+          "name": "Pack the final document",
+          "description": "Pack the final document: `python ooxml/scripts/pack.py <input_directory> <office_file>`",
+          "type": "instruction"
+        },
+        {
+          "id": 8,
+          "name": "**Get markdown representation**",
+          "description": "**Get markdown representation**: Convert document to markdown with tracked changes preserved:",
+          "type": "instruction"
+        },
+        {
+          "id": 9,
+          "name": "**Identify and group changes**",
+          "description": "**Identify and group changes**: Review the document and identify ALL changes needed, organizing them into logical batches:",
+          "type": "instruction"
+        },
+        {
+          "id": 10,
+          "name": "**Read documentation and unpack**",
+          "description": "**Read documentation and unpack**:",
+          "type": "instruction"
+        },
+        {
+          "id": 11,
+          "name": "**Implement changes in batches**",
+          "description": "**Implement changes in batches**: Group changes logically (by section, by type, or by proximity) and implement them together in a single script. This approach:",
+          "type": "instruction"
+        },
+        {
+          "id": 12,
+          "name": "**Pack the document**",
+          "description": "**Pack the document**: After all batches are complete, convert the unpacked directory back to .docx:",
+          "type": "instruction"
+        },
+        {
+          "id": 13,
+          "name": "**Final verification**",
+          "description": "**Final verification**: Do a comprehensive check of the complete document:",
+          "type": "instruction"
+        },
+        {
+          "id": 14,
+          "name": "**Convert DOCX to PDF**",
+          "description": "**Convert DOCX to PDF**:",
+          "type": "instruction"
+        },
+        {
+          "id": 15,
+          "name": "**Convert PDF pages to JPEG images**",
+          "description": "**Convert PDF pages to JPEG images**:",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/docx/skills/docx/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: docx
+description: "Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks"
+license: Proprietary. LICENSE.txt has complete terms
+---
+
+# DOCX creation, editing, and analysis
+
+## Overview
+
+A user may ask you to create, edit, or analyze the contents of a .docx file. A .docx file is essentially a ZIP archive containing XML files and other resources that you can read or edit. You have different tools and workflows available for different tasks.
+
+## Workflow Decision Tree
+
+### Reading/Analyzing Content
+Use "Text extraction" or "Raw XML access" sections below
+
+### Creating New Document
+Use "Creating a new Word document" workflow
+
+### Editing Existing Document
+- **Your own document + simple changes**
+  Use "Basic OOXML editing" workflow
+
+- **Someone else's document**
+  Use **"Redlining workflow"** (recommended default)
+
+- **Legal, academic, business, or government docs**
+  Use **"Redlining workflow"** (required)
+
+## Reading and analyzing content
+
+### Text extraction
+If you just need to read the text contents of a document, you should convert the document to markdown using pandoc. Pandoc provides excellent support for preserving document structure and can show tracked changes:
+
+```bash
+# Convert document to markdown with tracked changes
+pandoc --track-changes=all path-to-file.docx -o output.md
+# Options: --track-changes=accept/reject/all
+```
+
+### Raw XML access
+You need raw XML access for: comments, complex formatting, document structure, embedded media, and metadata. For any of these features, you'll need to unpack a document and read its raw XML contents.
+
+#### Unpacking a file
+`python ooxml/scripts/unpack.py <office_file> <output_directory>`
+
+#### Key file structures
+* `word/document.xml` - Main document contents
+* `word/comments.xml` - Comments referenced in document.xml
+* `word/media/` - Embedded images and media files
+* Tracked changes use `<w:ins>` (insertions) and `<w:del>` (deletions) tags
+
+## Creating a new Word document
+
+When creating a new Word document from scratch, use **docx-js**, which allows you to create Word documents using JavaScript/TypeScript.
+
+### Workflow
+1. **MANDATORY - READ ENTIRE FILE**: Read [`docx-js.md`](docx-js.md) (~500 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for detailed syntax, critical formatting rules, and best practices before proceeding with document creation.
+2. Create a JavaScript/TypeScript file using Document, Paragraph, TextRun components (You can assume all dependencies are installed, but if not, refer to the dependencies section below)
+3. Export as .docx using Packer.toBuffer()
+
+## Editing an existing Word document
+
+When editing an existing Word document, use the **Document library** (a Python library for OOXML manipulation). The library automatically handles infrastructure setup and provides methods for document manipulation. For complex scenarios, you can access the underlying DOM directly through the library.
+
+### Workflow
+1. **MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for the Document library API and XML patterns for directly editing document files.
+2. Unpack the document: `python ooxml/scripts/unpack.py <office_file> <output_directory>`
+3. Create and run a Python script using the Document library (see "Document Library" section in ooxml.md)
+4. Pack the final document: `python ooxml/scripts/pack.py <input_directory> <office_file>`
+
+The Document library provides both high-level methods for common operations and direct DOM access for complex scenarios.
+
+## Redlining workflow for document review
+
+This workflow allows you to plan comprehensive tracked changes using markdown before implementing them in OOXML. **CRITICAL**: For complete tracked changes, you must implement ALL changes systematically.
+
+**Batching Strategy**: Group related changes into batches of 3-10 changes. This makes debugging manageable while maintaining efficiency. Test each batch before moving to the next.
+
+**Principle: Minimal, Precise Edits**
+When implementing tracked changes, only mark text that actually changes. Repeating unchanged text makes edits harder to review and appears unprofessional. Break replacements into: [unchanged text] + [deletion] + [insertion] + [unchanged text]. Preserve the original run's RSID for unchanged text by extracting the `<w:r>` element from the original and reusing it.
+
+Example - Changing "30 days" to "60 days" in a sentence:
+```python
+# BAD - Replaces entire sentence
+'<w:del><w:r><w:delText>The term is 30 days.</w:delText></w:r></w:del><w:ins><w:r><w:t>The term is 60 days.</w:t></w:r></w:ins>'
+
+# GOOD - Only marks what changed, preserves original <w:r> for unchanged text
+'<w:r w:rsidR="00AB12CD"><w:t>The term is </w:t></w:r><w:del><w:r><w:delText>30</w:delText></w:r></w:del><w:ins><w:r><w:t>60</w:t></w:r></w:ins><w:r w:rsidR="00AB12CD"><w:t> days.</w:t></w:r>'
+```
+
+### Tracked changes workflow
+
+1. **Get markdown representation**: Convert document to markdown with tracked changes preserved:
+   ```bash
+   pandoc --track-changes=all path-to-file.docx -o current.md
+   ```
+
+2. **Identify and group changes**: Review the document and identify ALL changes needed, organizing them into logical batches:
+
+   **Location methods** (for finding changes in XML):
+   - Section/heading numbers (e.g., "Section 3.2", "Article IV")
+   - Paragraph identifiers if numbered
+   - Grep patterns with unique surrounding text
+   - Document structure (e.g., "first paragraph", "signature block")
+   - **DO NOT use markdown line numbers** - they don't map to XML structure
+
+   **Batch organization** (group 3-10 related changes per batch):
+   - By section: "Batch 1: Section 2 amendments", "Batch 2: Section 5 updates"
+   - By type: "Batch 1: Date corrections", "Batch 2: Party name changes"
+   - By complexity: Start with simple text replacements, then tackle complex structural changes
+   - Sequential: "Batch 1: Pages 1-3", "Batch 2: Pages 4-6"
+
+3. **Read documentation and unpack**:
+   - **MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Pay special attention to the "Document Library" and "Tracked Change Patterns" sections.
+   - **Unpack the document**: `python ooxml/scripts/unpack.py <file.docx> <dir>`
+   - **Note the suggested RSID**: The unpack script will suggest an RSID to use for your tracked changes. Copy this RSID for use in step 4b.
+
+4. **Implement changes in batches**: Group changes logically (by section, by type, or by proximity) and implement them together in a single script. This approach:
+   - Makes debugging easier (smaller batch = easier to isolate errors)
+   - Allows incremental progress
+   - Maintains efficiency (batch size of 3-10 changes works well)
+
+   **Suggested batch groupings:**
+   - By document section (e.g., "Section 3 changes", "Definitions", "Termination clause")
+   - By change type (e.g., "Date changes", "Party name updates", "Legal term replacements")
+   - By proximity (e.g., "Changes on pages 1-3", "Changes in first half of document")
+
+   For each batch of related changes:
+
+   **a. Map text to XML**: Grep for text in `word/document.xml` to verify how text is split across `<w:r>` elements.
+
+   **b. Create and run script**: Use `get_node` to find nodes, implement changes, then `doc.save()`. See **"Document Library"** section in ooxml.md for patterns.
+
+   **Note**: Always grep `word/document.xml` immediately before writing a script to get current line numbers and verify text content. Line numbers change after each script run.
+
+5. **Pack the document**: After all batches are complete, convert the unpacked directory back to .docx:
+   ```bash
+   python ooxml/scripts/pack.py unpacked reviewed-document.docx
+   ```
+
+6. **Final verification**: Do a comprehensive check of the complete document:
+   - Convert final document to markdown:
+     ```bash
+     pandoc --track-changes=all reviewed-document.docx -o verification.md
+     ```
+   - Verify ALL changes were applied correctly:
+     ```bash
+     grep "original phrase" verification.md  # Should NOT find it
+     grep "replacement phrase" verification.md  # Should find it
+     ```
+   - Check that no unintended changes were introduced
+
+
+## Converting Documents to Images
+
+To visually analyze Word documents, convert them to images using a two-step process:
+
+1. **Convert DOCX to PDF**:
+   ```bash
+   soffice --headless --convert-to pdf document.docx
+   ```
+
+2. **Convert PDF pages to JPEG images**:
+   ```bash
+   pdftoppm -jpeg -r 150 document.pdf page
+   ```
+   This creates files like `page-1.jpg`, `page-2.jpg`, etc.
+
+Options:
+- `-r 150`: Sets resolution to 150 DPI (adjust for quality/size balance)
+- `-jpeg`: Output JPEG format (use `-png` for PNG if preferred)
+- `-f N`: First page to convert (e.g., `-f 2` starts from page 2)
+- `-l N`: Last page to convert (e.g., `-l 5` stops at page 5)
+- `page`: Prefix for output files
+
+Example for specific range:
+```bash
+pdftoppm -jpeg -r 150 -f 2 -l 5 document.pdf page  # Converts only pages 2-5
+```
+
+## Code Style Guidelines
+**IMPORTANT**: When generating code for DOCX operations:
+- Write concise code
+- Avoid verbose variable names and redundant operations
+- Avoid unnecessary print statements
+
+## Dependencies
+
+Required dependencies (install if not available):
+
+- **pandoc**: `sudo apt-get install pandoc` (for text extraction)
+- **docx**: `npm install -g docx` (for creating new documents)
+- **LibreOffice**: `sudo apt-get install libreoffice` (for PDF conversion)
+- **Poppler**: `sudo apt-get install poppler-utils` (for pdftoppm to convert PDF to images)
+- **defusedxml**: `pip install defusedxml` (for secure XML parsing)

adapters-output/codebuddy/docx/workflows/docx.json

@@ -0,0 +1,99 @@
+{
+  "id": "docx",
+  "name": "DOCX creation, editing, and analysis",
+  "description": "Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**MANDATORY - READ ENTIRE FILE**",
+      "description": "**MANDATORY - READ ENTIRE FILE**: Read [`docx-js.md`](docx-js.md) (~500 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for detailed syntax, critical formatting rules, and best practices before proceeding with document creation.",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "Create a JavaScript/TypeScript file using Document, Paragraph, TextRun components (You can assume all dependencies are installed, but if not, refer to the dependencies section below)",
+      "description": "Create a JavaScript/TypeScript file using Document, Paragraph, TextRun components (You can assume all dependencies are installed, but if not, refer to the dependencies section below)",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "Export as .docx using Packer.toBuffer()",
+      "description": "Export as .docx using Packer.toBuffer()",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**MANDATORY - READ ENTIRE FILE**",
+      "description": "**MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for the Document library API and XML patterns for directly editing document files.",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "Unpack the document",
+      "description": "Unpack the document: `python ooxml/scripts/unpack.py <office_file> <output_directory>`",
+      "type": "instruction"
+    },
+    {
+      "id": 6,
+      "name": "Create and run a Python script using the Document library (see \"Document Library\" section in ooxml.md)",
+      "description": "Create and run a Python script using the Document library (see \"Document Library\" section in ooxml.md)",
+      "type": "instruction"
+    },
+    {
+      "id": 7,
+      "name": "Pack the final document",
+      "description": "Pack the final document: `python ooxml/scripts/pack.py <input_directory> <office_file>`",
+      "type": "instruction"
+    },
+    {
+      "id": 8,
+      "name": "**Get markdown representation**",
+      "description": "**Get markdown representation**: Convert document to markdown with tracked changes preserved:",
+      "type": "instruction"
+    },
+    {
+      "id": 9,
+      "name": "**Identify and group changes**",
+      "description": "**Identify and group changes**: Review the document and identify ALL changes needed, organizing them into logical batches:",
+      "type": "instruction"
+    },
+    {
+      "id": 10,
+      "name": "**Read documentation and unpack**",
+      "description": "**Read documentation and unpack**:",
+      "type": "instruction"
+    },
+    {
+      "id": 11,
+      "name": "**Implement changes in batches**",
+      "description": "**Implement changes in batches**: Group changes logically (by section, by type, or by proximity) and implement them together in a single script. This approach:",
+      "type": "instruction"
+    },
+    {
+      "id": 12,
+      "name": "**Pack the document**",
+      "description": "**Pack the document**: After all batches are complete, convert the unpacked directory back to .docx:",
+      "type": "instruction"
+    },
+    {
+      "id": 13,
+      "name": "**Final verification**",
+      "description": "**Final verification**: Do a comprehensive check of the complete document:",
+      "type": "instruction"
+    },
+    {
+      "id": 14,
+      "name": "**Convert DOCX to PDF**",
+      "description": "**Convert DOCX to PDF**:",
+      "type": "instruction"
+    },
+    {
+      "id": 15,
+      "name": "**Convert PDF pages to JPEG images**",
+      "description": "**Convert PDF pages to JPEG images**:",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/frontend-design/manifest.json

@@ -0,0 +1,36 @@
+{
+  "name": "frontend-design",
+  "version": "1.0.0",
+  "description": "Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "frontend-design",
+      "name": "frontend-design",
+      "description": "Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "analyze",
+          "description": "Analyze requirements",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "execute",
+          "description": "Execute skill task",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "output",
+          "description": "Generate output",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/frontend-design/skills/frontend-design/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: frontend-design
+description: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.
+license: Complete terms in LICENSE.txt
+---
+
+This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.
+
+The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.
+
+## Design Thinking
+
+Before coding, understand the context and commit to a BOLD aesthetic direction:
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
+- **Constraints**: Technical requirements (framework, performance, accessibility).
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.
+
+Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
+
+## Frontend Aesthetics Guidelines
+
+Focus on:
+- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
+- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
+- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
+- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
+- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.
+
+NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.
+
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.
+
+**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.
+
+Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.

adapters-output/codebuddy/frontend-design/workflows/frontend-design.json

@@ -0,0 +1,27 @@
+{
+  "id": "frontend-design",
+  "name": "frontend-design",
+  "description": "Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "analyze",
+      "description": "Analyze requirements",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "execute",
+      "description": "Execute skill task",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "output",
+      "description": "Generate output",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/internal-comms/manifest.json

@@ -0,0 +1,36 @@
+{
+  "name": "internal-comms",
+  "version": "1.0.0",
+  "description": "A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "internal-comms",
+      "name": "internal-comms",
+      "description": "A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**Identify the communication type** from the request",
+          "description": "**Identify the communication type** from the request",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**Load the appropriate guideline file** from the `examples/` directory",
+          "description": "**Load the appropriate guideline file** from the `examples/` directory:",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**Follow the specific instructions** in that file for formatting, tone, and content gathering",
+          "description": "**Follow the specific instructions** in that file for formatting, tone, and content gathering",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/internal-comms/skills/internal-comms/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: internal-comms
+description: A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).
+license: Complete terms in LICENSE.txt
+---
+
+## When to use this skill
+To write internal communications, use this skill for:
+- 3P updates (Progress, Plans, Problems)
+- Company newsletters
+- FAQ responses
+- Status reports
+- Leadership updates
+- Project updates
+- Incident reports
+
+## How to use this skill
+
+To write any internal communication:
+
+1. **Identify the communication type** from the request
+2. **Load the appropriate guideline file** from the `examples/` directory:
+    - `examples/3p-updates.md` - For Progress/Plans/Problems team updates
+    - `examples/company-newsletter.md` - For company-wide newsletters
+    - `examples/faq-answers.md` - For answering frequently asked questions
+    - `examples/general-comms.md` - For anything else that doesn't explicitly match one of the above
+3. **Follow the specific instructions** in that file for formatting, tone, and content gathering
+
+If the communication type doesn't match any existing guideline, ask for clarification or more context about the desired format.
+
+## Keywords
+3P updates, company newsletter, company comms, weekly update, faqs, common questions, updates, internal comms

adapters-output/codebuddy/internal-comms/workflows/internal-comms.json

@@ -0,0 +1,27 @@
+{
+  "id": "internal-comms",
+  "name": "internal-comms",
+  "description": "A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**Identify the communication type** from the request",
+      "description": "**Identify the communication type** from the request",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**Load the appropriate guideline file** from the `examples/` directory",
+      "description": "**Load the appropriate guideline file** from the `examples/` directory:",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**Follow the specific instructions** in that file for formatting, tone, and content gathering",
+      "description": "**Follow the specific instructions** in that file for formatting, tone, and content gathering",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/learning-assessor/manifest.json

@@ -0,0 +1,48 @@
+{
+  "name": "learning-assessor",
+  "version": "1.0.0",
+  "description": "帮助创建学习评估工具，包括测验题目、评估标准、评分 rubric 和学习分析。适用于评估学习效果、设计考试题目或分析学习数据。",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "learning-assessor",
+      "name": "学习评估技能",
+      "description": "帮助创建学习评估工具，包括测验题目、评估标准、评分 rubric 和学习分析。适用于评估学习效果、设计考试题目或分析学习数据。",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**目标对齐**",
+          "description": "**目标对齐**: 每道题目都应对应明确的学习目标",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**难度梯度**",
+          "description": "**难度梯度**: 题目应覆盖不同认知层次（记忆、理解、应用、分析、评价、创造）",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**清晰明确**",
+          "description": "**清晰明确**: 题目表述清晰，避免歧义",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**公平性**",
+          "description": "**公平性**: 确保题目对所有学习者公平",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**有效性**",
+          "description": "**有效性**: 题目应能有效测量目标知识和技能",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/learning-assessor/skills/learning-assessor/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: learning-assessor
+description: 帮助创建学习评估工具，包括测验题目、评估标准、评分 rubric 和学习分析。适用于评估学习效果、设计考试题目或分析学习数据。
+---
+
+# 学习评估技能
+
+## 概述
+
+本技能帮助您创建各种学习评估工具，包括测验题目、评估标准、评分 rubric 和学习分析。
+
+**关键词**: 学习评估、测验设计、评分标准、rubric、学习分析、考试题目
+
+## 核心功能
+
+### 1. 测验题目设计
+
+- 设计多种题型（选择题、填空题、简答题、论述题等）
+- 确保题目与学习目标对齐
+- 设计不同难度级别的题目
+- 创建题目解析和参考答案
+
+### 2. 评估标准制定
+
+- 制定清晰的评估标准
+- 设计评分细则和权重分配
+- 创建评分 rubric（评分量规）
+- 确保评估的客观性和一致性
+
+### 3. 学习分析
+
+- 分析学习数据和学习趋势
+- 识别学习难点和薄弱环节
+- 提供个性化学习建议
+- 生成学习报告和反馈
+
+### 4. 评估工具创建
+
+- 创建在线测验和问卷
+- 设计项目评估表
+- 创建同伴评估工具
+- 设计自我评估工具
+
+## 使用指南
+
+### 题目设计原则
+
+1. **目标对齐**: 每道题目都应对应明确的学习目标
+2. **难度梯度**: 题目应覆盖不同认知层次（记忆、理解、应用、分析、评价、创造）
+3. **清晰明确**: 题目表述清晰，避免歧义
+4. **公平性**: 确保题目对所有学习者公平
+5. **有效性**: 题目应能有效测量目标知识和技能
+
+### Rubric 设计
+
+Rubric 应包含：
+
+- **评估维度**: 要评估的具体方面
+- **表现等级**: 不同表现水平的描述
+- **评分标准**: 每个等级的评分标准
+- **权重分配**: 各维度的权重
+
+### 学习分析维度
+
+- **知识掌握度**: 对知识点的掌握情况
+- **技能应用**: 技能的应用水平
+- **学习进度**: 学习进度和完成情况
+- **学习困难**: 识别学习中的困难点
+- **改进建议**: 提供针对性的改进建议
+
+## 输出格式
+
+评估工具应包含：
+
+- **评估目标**: 明确要评估的内容
+- **评估方式**: 使用的评估方法和工具
+- **评估标准**: 详细的评分标准或 rubric
+- **评估题目**: 具体的评估题目（如适用）
+- **分析报告**: 学习分析和反馈建议
+
+## 最佳实践
+
+- 使用多种评估方式，避免单一化
+- 设计形成性评估，及时反馈
+- 确保评估标准清晰、可操作
+- 提供建设性的反馈意见
+- 关注学习过程，不仅看结果
+- 鼓励自我评估和同伴评估

adapters-output/codebuddy/learning-assessor/workflows/learning-assessor.json

@@ -0,0 +1,39 @@
+{
+  "id": "learning-assessor",
+  "name": "学习评估技能",
+  "description": "帮助创建学习评估工具，包括测验题目、评估标准、评分 rubric 和学习分析。适用于评估学习效果、设计考试题目或分析学习数据。",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**目标对齐**",
+      "description": "**目标对齐**: 每道题目都应对应明确的学习目标",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**难度梯度**",
+      "description": "**难度梯度**: 题目应覆盖不同认知层次（记忆、理解、应用、分析、评价、创造）",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**清晰明确**",
+      "description": "**清晰明确**: 题目表述清晰，避免歧义",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**公平性**",
+      "description": "**公平性**: 确保题目对所有学习者公平",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**有效性**",
+      "description": "**有效性**: 题目应能有效测量目标知识和技能",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/mcp-builder/manifest.json

@@ -0,0 +1,42 @@
+{
+  "name": "mcp-builder",
+  "version": "1.0.0",
+  "description": "Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "mcp-builder",
+      "name": "MCP Server Development Guide",
+      "description": "Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**Tool Inspection**",
+          "description": "**Tool Inspection**: List available tools and understand their capabilities",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**Content Exploration**",
+          "description": "**Content Exploration**: Use READ-ONLY operations to explore available data",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**Question Generation**",
+          "description": "**Question Generation**: Create 10 complex, realistic questions",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**Answer Verification**",
+          "description": "**Answer Verification**: Solve each question yourself to verify answers",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/mcp-builder/skills/mcp-builder/SKILL.md

@@ -0,0 +1,236 @@
+---
+name: mcp-builder
+description: Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).
+license: Complete terms in LICENSE.txt
+---
+
+# MCP Server Development Guide
+
+## Overview
+
+Create MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. The quality of an MCP server is measured by how well it enables LLMs to accomplish real-world tasks.
+
+---
+
+# Process
+
+## 🚀 High-Level Workflow
+
+Creating a high-quality MCP server involves four main phases:
+
+### Phase 1: Deep Research and Planning
+
+#### 1.1 Understand Modern MCP Design
+
+**API Coverage vs. Workflow Tools:**
+Balance comprehensive API endpoint coverage with specialized workflow tools. Workflow tools can be more convenient for specific tasks, while comprehensive coverage gives agents flexibility to compose operations. Performance varies by client—some clients benefit from code execution that combines basic tools, while others work better with higher-level workflows. When uncertain, prioritize comprehensive API coverage.
+
+**Tool Naming and Discoverability:**
+Clear, descriptive tool names help agents find the right tools quickly. Use consistent prefixes (e.g., `github_create_issue`, `github_list_repos`) and action-oriented naming.
+
+**Context Management:**
+Agents benefit from concise tool descriptions and the ability to filter/paginate results. Design tools that return focused, relevant data. Some clients support code execution which can help agents filter and process data efficiently.
+
+**Actionable Error Messages:**
+Error messages should guide agents toward solutions with specific suggestions and next steps.
+
+#### 1.2 Study MCP Protocol Documentation
+
+**Navigate the MCP specification:**
+
+Start with the sitemap to find relevant pages: `https://modelcontextprotocol.io/sitemap.xml`
+
+Then fetch specific pages with `.md` suffix for markdown format (e.g., `https://modelcontextprotocol.io/specification/draft.md`).
+
+Key pages to review:
+- Specification overview and architecture
+- Transport mechanisms (streamable HTTP, stdio)
+- Tool, resource, and prompt definitions
+
+#### 1.3 Study Framework Documentation
+
+**Recommended stack:**
+- **Language**: TypeScript (high-quality SDK support and good compatibility in many execution environments e.g. MCPB. Plus AI models are good at generating TypeScript code, benefiting from its broad usage, static typing and good linting tools)
+- **Transport**: Streamable HTTP for remote servers, using stateless JSON (simpler to scale and maintain, as opposed to stateful sessions and streaming responses). stdio for local servers.
+
+**Load framework documentation:**
+
+- **MCP Best Practices**: [📋 View Best Practices](./reference/mcp_best_practices.md) - Core guidelines
+
+**For TypeScript (recommended):**
+- **TypeScript SDK**: Use WebFetch to load `https://raw.githubusercontent.com/modelcontextprotocol/typescript-sdk/main/README.md`
+- [⚡ TypeScript Guide](./reference/node_mcp_server.md) - TypeScript patterns and examples
+
+**For Python:**
+- **Python SDK**: Use WebFetch to load `https://raw.githubusercontent.com/modelcontextprotocol/python-sdk/main/README.md`
+- [🐍 Python Guide](./reference/python_mcp_server.md) - Python patterns and examples
+
+#### 1.4 Plan Your Implementation
+
+**Understand the API:**
+Review the service's API documentation to identify key endpoints, authentication requirements, and data models. Use web search and WebFetch as needed.
+
+**Tool Selection:**
+Prioritize comprehensive API coverage. List endpoints to implement, starting with the most common operations.
+
+---
+
+### Phase 2: Implementation
+
+#### 2.1 Set Up Project Structure
+
+See language-specific guides for project setup:
+- [⚡ TypeScript Guide](./reference/node_mcp_server.md) - Project structure, package.json, tsconfig.json
+- [🐍 Python Guide](./reference/python_mcp_server.md) - Module organization, dependencies
+
+#### 2.2 Implement Core Infrastructure
+
+Create shared utilities:
+- API client with authentication
+- Error handling helpers
+- Response formatting (JSON/Markdown)
+- Pagination support
+
+#### 2.3 Implement Tools
+
+For each tool:
+
+**Input Schema:**
+- Use Zod (TypeScript) or Pydantic (Python)
+- Include constraints and clear descriptions
+- Add examples in field descriptions
+
+**Output Schema:**
+- Define `outputSchema` where possible for structured data
+- Use `structuredContent` in tool responses (TypeScript SDK feature)
+- Helps clients understand and process tool outputs
+
+**Tool Description:**
+- Concise summary of functionality
+- Parameter descriptions
+- Return type schema
+
+**Implementation:**
+- Async/await for I/O operations
+- Proper error handling with actionable messages
+- Support pagination where applicable
+- Return both text content and structured data when using modern SDKs
+
+**Annotations:**
+- `readOnlyHint`: true/false
+- `destructiveHint`: true/false
+- `idempotentHint`: true/false
+- `openWorldHint`: true/false
+
+---
+
+### Phase 3: Review and Test
+
+#### 3.1 Code Quality
+
+Review for:
+- No duplicated code (DRY principle)
+- Consistent error handling
+- Full type coverage
+- Clear tool descriptions
+
+#### 3.2 Build and Test
+
+**TypeScript:**
+- Run `npm run build` to verify compilation
+- Test with MCP Inspector: `npx @modelcontextprotocol/inspector`
+
+**Python:**
+- Verify syntax: `python -m py_compile your_server.py`
+- Test with MCP Inspector
+
+See language-specific guides for detailed testing approaches and quality checklists.
+
+---
+
+### Phase 4: Create Evaluations
+
+After implementing your MCP server, create comprehensive evaluations to test its effectiveness.
+
+**Load [✅ Evaluation Guide](./reference/evaluation.md) for complete evaluation guidelines.**
+
+#### 4.1 Understand Evaluation Purpose
+
+Use evaluations to test whether LLMs can effectively use your MCP server to answer realistic, complex questions.
+
+#### 4.2 Create 10 Evaluation Questions
+
+To create effective evaluations, follow the process outlined in the evaluation guide:
+
+1. **Tool Inspection**: List available tools and understand their capabilities
+2. **Content Exploration**: Use READ-ONLY operations to explore available data
+3. **Question Generation**: Create 10 complex, realistic questions
+4. **Answer Verification**: Solve each question yourself to verify answers
+
+#### 4.3 Evaluation Requirements
+
+Ensure each question is:
+- **Independent**: Not dependent on other questions
+- **Read-only**: Only non-destructive operations required
+- **Complex**: Requiring multiple tool calls and deep exploration
+- **Realistic**: Based on real use cases humans would care about
+- **Verifiable**: Single, clear answer that can be verified by string comparison
+- **Stable**: Answer won't change over time
+
+#### 4.4 Output Format
+
+Create an XML file with this structure:
+
+```xml
+<evaluation>
+  <qa_pair>
+    <question>Find discussions about AI model launches with animal codenames. One model needed a specific safety designation that uses the format ASL-X. What number X was being determined for the model named after a spotted wild cat?</question>
+    <answer>3</answer>
+  </qa_pair>
+<!-- More qa_pairs... -->
+</evaluation>
+```
+
+---
+
+# Reference Files
+
+## 📚 Documentation Library
+
+Load these resources as needed during development:
+
+### Core MCP Documentation (Load First)
+- **MCP Protocol**: Start with sitemap at `https://modelcontextprotocol.io/sitemap.xml`, then fetch specific pages with `.md` suffix
+- [📋 MCP Best Practices](./reference/mcp_best_practices.md) - Universal MCP guidelines including:
+  - Server and tool naming conventions
+  - Response format guidelines (JSON vs Markdown)
+  - Pagination best practices
+  - Transport selection (streamable HTTP vs stdio)
+  - Security and error handling standards
+
+### SDK Documentation (Load During Phase 1/2)
+- **Python SDK**: Fetch from `https://raw.githubusercontent.com/modelcontextprotocol/python-sdk/main/README.md`
+- **TypeScript SDK**: Fetch from `https://raw.githubusercontent.com/modelcontextprotocol/typescript-sdk/main/README.md`
+
+### Language-Specific Implementation Guides (Load During Phase 2)
+- [🐍 Python Implementation Guide](./reference/python_mcp_server.md) - Complete Python/FastMCP guide with:
+  - Server initialization patterns
+  - Pydantic model examples
+  - Tool registration with `@mcp.tool`
+  - Complete working examples
+  - Quality checklist
+
+- [⚡ TypeScript Implementation Guide](./reference/node_mcp_server.md) - Complete TypeScript guide with:
+  - Project structure
+  - Zod schema patterns
+  - Tool registration with `server.registerTool`
+  - Complete working examples
+  - Quality checklist
+
+### Evaluation Guide (Load During Phase 4)
+- [✅ Evaluation Guide](./reference/evaluation.md) - Complete evaluation creation guide with:
+  - Question creation guidelines
+  - Answer verification strategies
+  - XML format specifications
+  - Example questions and answers
+  - Running an evaluation with the provided scripts

adapters-output/codebuddy/mcp-builder/workflows/mcp-builder.json

@@ -0,0 +1,33 @@
+{
+  "id": "mcp-builder",
+  "name": "MCP Server Development Guide",
+  "description": "Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**Tool Inspection**",
+      "description": "**Tool Inspection**: List available tools and understand their capabilities",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**Content Exploration**",
+      "description": "**Content Exploration**: Use READ-ONLY operations to explore available data",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**Question Generation**",
+      "description": "**Question Generation**: Create 10 complex, realistic questions",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**Answer Verification**",
+      "description": "**Answer Verification**: Solve each question yourself to verify answers",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/mermaid/manifest.json

@@ -0,0 +1,54 @@
+{
+  "name": "mermaid",
+  "version": "1.0.0",
+  "description": "A comprehensive skill for creating all types of Mermaid diagrams including flowcharts, sequence diagrams, class diagrams, state diagrams, entity relationship diagrams, user journey diagrams, Gantt charts, pie charts, quadrant charts, requirement diagrams, Git graphs, C4 diagrams, mindmaps, timelines, ZenUML, Sankey diagrams, XY charts, block diagrams, packet diagrams, Kanban boards, architecture diagrams, radar charts, and treemaps. Use this skill whenever the user requests to create, draw, or visualize any diagram, flowchart, or structured chart using Mermaid syntax.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "mermaid",
+      "name": "mermaid",
+      "description": "A comprehensive skill for creating all types of Mermaid diagrams including flowcharts, sequence diagrams, class diagrams, state diagrams, entity relationship diagrams, user journey diagrams, Gantt charts, pie charts, quadrant charts, requirement diagrams, Git graphs, C4 diagrams, mindmaps, timelines, ZenUML, Sankey diagrams, XY charts, block diagrams, packet diagrams, Kanban boards, architecture diagrams, radar charts, and treemaps. Use this skill whenever the user requests to create, draw, or visualize any diagram, flowchart, or structured chart using Mermaid syntax.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**Identify the diagram type** from the user's request",
+          "description": "**Identify the diagram type** from the user's request:",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**Load the appropriate example file** from the `examples/` directory",
+          "description": "**Load the appropriate example file** from the `examples/` directory:",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**Follow the specific instructions** in that example file for syntax, structure, and best practices",
+          "description": "**Follow the specific instructions** in that example file for syntax, structure, and best practices",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**Generate the Mermaid code** wrapped in a code block",
+          "description": "**Generate the Mermaid code** wrapped in a code block:",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**Include styling and configuration** when needed",
+          "description": "**Include styling and configuration** when needed:",
+          "type": "instruction"
+        },
+        {
+          "id": 6,
+          "name": "**Validate the syntax**",
+          "description": "**Validate the syntax**:",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/mermaid/skills/mermaid/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: mermaid
+description: A comprehensive skill for creating all types of Mermaid diagrams including flowcharts, sequence diagrams, class diagrams, state diagrams, entity relationship diagrams, user journey diagrams, Gantt charts, pie charts, quadrant charts, requirement diagrams, Git graphs, C4 diagrams, mindmaps, timelines, ZenUML, Sankey diagrams, XY charts, block diagrams, packet diagrams, Kanban boards, architecture diagrams, radar charts, and treemaps. Use this skill whenever the user requests to create, draw, or visualize any diagram, flowchart, or structured chart using Mermaid syntax.
+license: Complete terms in LICENSE.txt
+---
+
+## When to use this skill
+
+Use this skill whenever the user wants to:
+- Create any type of diagram or flowchart
+- Visualize processes, workflows, or system architectures
+- Draw sequence diagrams, class diagrams, or state diagrams
+- Create project timelines (Gantt charts)
+- Visualize data relationships (ER diagrams, entity relationships)
+- Create user journey maps
+- Generate pie charts, quadrant charts, or other data visualizations
+- Draw Git branching structures
+- Create mindmaps or hierarchical structures
+- Visualize system architectures (C4 diagrams)
+- Create timelines or event sequences
+- Generate any other diagram type supported by Mermaid
+
+## How to use this skill
+
+To create a Mermaid diagram:
+
+1. **Identify the diagram type** from the user's request:
+   - Flowchart/flow chart/流程图 → `flowchart` or `graph`
+   - Sequence diagram/时序图 → `sequenceDiagram`
+   - Class diagram/类图 → `classDiagram`
+   - State diagram/状态图 → `stateDiagram` or `stateDiagram-v2`
+   - Entity relationship diagram/实体关系图 → `erDiagram`
+   - User journey/用户旅程图 → `journey`
+   - Gantt chart/甘特图 → `gantt`
+   - Pie chart/饼图 → `pie`
+   - Quadrant chart/象限图 → `quadrantChart`
+   - Requirement diagram/需求图 → `requirementDiagram`
+   - Git graph/Git图 → `gitGraph`
+   - C4 diagram/C4图 → `C4Context` or other C4 types
+   - Mindmap/思维导图 → `mindmap`
+   - Timeline/时间线图 → `timeline`
+   - ZenUML/禅UML → `zenuml`
+   - Sankey diagram/桑基图 → `sankey`
+   - XY chart/XY图 → `xychart`
+   - Block diagram/方块图 → `block`
+   - Packet diagram/数据包图 → `packet`
+   - Kanban/看板图 → `kanban`
+   - Architecture diagram/架构图 → `architecture-beta`
+   - Radar chart/雷达图 → `radar-beta`
+   - Treemap/树状图 → `treemap-beta`
+
+2. **Load the appropriate example file** from the `examples/` directory:
+   - `examples/flowchart.md` - For flowcharts and process diagrams
+   - `examples/sequence.md` - For sequence diagrams showing interactions
+   - `examples/class.md` - For class diagrams and object-oriented designs
+   - `examples/state.md` - For state diagrams and state machines
+   - `examples/er.md` - For entity relationship diagrams
+   - `examples/journey.md` - For user journey maps
+   - `examples/gantt.md` - For Gantt charts and project timelines
+   - `examples/pie.md` - For pie charts
+   - `examples/quadrant.md` - For quadrant charts
+   - `examples/requirement.md` - For requirement diagrams
+   - `examples/gitgraph.md` - For Git branching diagrams
+   - `examples/c4.md` - For C4 architecture diagrams
+   - `examples/mindmap.md` - For mindmaps
+   - `examples/timeline.md` - For timeline diagrams
+   - `examples/zenuml.md` - For ZenUML diagrams
+   - `examples/sankey.md` - For Sankey flow diagrams
+   - `examples/xychart.md` - For XY charts (bar/line charts)
+   - `examples/block.md` - For block diagrams
+   - `examples/packet.md` - For packet diagrams
+   - `examples/kanban.md` - For Kanban boards
+   - `examples/architecture.md` - For architecture diagrams
+   - `examples/radar.md` - For radar charts
+   - `examples/treemap.md` - For treemap diagrams
+
+3. **Follow the specific instructions** in that example file for syntax, structure, and best practices
+
+4. **Generate the Mermaid code** wrapped in a code block:
+   ```mermaid
+   <diagram-type>
+   ...diagram content...
+   ```
+
+5. **Include styling and configuration** when needed:
+   - Use `%%{ init: { theme: 'base' } }%%` for theme configuration
+   - Apply `style` directives for node styling
+   - Use `classDef` for reusable style classes
+
+6. **Validate the syntax**:
+   - Ensure all required elements are present
+   - Check that relationships and connections are properly defined
+   - Verify date formats for Gantt charts
+   - Confirm data formats for charts (pie, quadrant, etc.)
+
+If the diagram type doesn't match any existing example, refer to the Mermaid documentation or ask the user for clarification about the desired visualization.
+
+## Keywords
+
+mermaid, diagram, flowchart, flow chart, sequence diagram, class diagram, state diagram, entity relationship, ER diagram, user journey, Gantt chart, pie chart, quadrant chart, requirement diagram, Git graph, C4 diagram, mindmap, timeline, ZenUML, Sankey diagram, XY chart, block diagram, packet diagram, Kanban, architecture diagram, radar chart, treemap, 流程图, 时序图, 类图, 状态图, 实体关系图, 用户旅程图, 甘特图, 饼图, 象限图, 需求图, Git图, C4图, 思维导图, 时间线图, 桑基图, XY图, 方块图, 数据包图, 看板图, 架构图, 雷达图, 树状图

adapters-output/codebuddy/mermaid/workflows/mermaid.json

@@ -0,0 +1,45 @@
+{
+  "id": "mermaid",
+  "name": "mermaid",
+  "description": "A comprehensive skill for creating all types of Mermaid diagrams including flowcharts, sequence diagrams, class diagrams, state diagrams, entity relationship diagrams, user journey diagrams, Gantt charts, pie charts, quadrant charts, requirement diagrams, Git graphs, C4 diagrams, mindmaps, timelines, ZenUML, Sankey diagrams, XY charts, block diagrams, packet diagrams, Kanban boards, architecture diagrams, radar charts, and treemaps. Use this skill whenever the user requests to create, draw, or visualize any diagram, flowchart, or structured chart using Mermaid syntax.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**Identify the diagram type** from the user's request",
+      "description": "**Identify the diagram type** from the user's request:",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**Load the appropriate example file** from the `examples/` directory",
+      "description": "**Load the appropriate example file** from the `examples/` directory:",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**Follow the specific instructions** in that example file for syntax, structure, and best practices",
+      "description": "**Follow the specific instructions** in that example file for syntax, structure, and best practices",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**Generate the Mermaid code** wrapped in a code block",
+      "description": "**Generate the Mermaid code** wrapped in a code block:",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**Include styling and configuration** when needed",
+      "description": "**Include styling and configuration** when needed:",
+      "type": "instruction"
+    },
+    {
+      "id": 6,
+      "name": "**Validate the syntax**",
+      "description": "**Validate the syntax**:",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/pdf/manifest.json

@@ -0,0 +1,36 @@
+{
+  "name": "pdf",
+  "version": "1.0.0",
+  "description": "Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "pdf",
+      "name": "PDF Processing Guide",
+      "description": "Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "analyze",
+          "description": "Analyze requirements",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "execute",
+          "description": "Execute skill task",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "output",
+          "description": "Generate output",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/pdf/skills/pdf/SKILL.md

@@ -0,0 +1,294 @@
+---
+name: pdf
+description: Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.
+license: Proprietary. LICENSE.txt has complete terms
+---
+
+# PDF Processing Guide
+
+## Overview
+
+This guide covers essential PDF processing operations using Python libraries and command-line tools. For advanced features, JavaScript libraries, and detailed examples, see reference.md. If you need to fill out a PDF form, read forms.md and follow its instructions.
+
+## Quick Start
+
+```python
+from pypdf import PdfReader, PdfWriter
+
+# Read a PDF
+reader = PdfReader("document.pdf")
+print(f"Pages: {len(reader.pages)}")
+
+# Extract text
+text = ""
+for page in reader.pages:
+    text += page.extract_text()
+```
+
+## Python Libraries
+
+### pypdf - Basic Operations
+
+#### Merge PDFs
+```python
+from pypdf import PdfWriter, PdfReader
+
+writer = PdfWriter()
+for pdf_file in ["doc1.pdf", "doc2.pdf", "doc3.pdf"]:
+    reader = PdfReader(pdf_file)
+    for page in reader.pages:
+        writer.add_page(page)
+
+with open("merged.pdf", "wb") as output:
+    writer.write(output)
+```
+
+#### Split PDF
+```python
+reader = PdfReader("input.pdf")
+for i, page in enumerate(reader.pages):
+    writer = PdfWriter()
+    writer.add_page(page)
+    with open(f"page_{i+1}.pdf", "wb") as output:
+        writer.write(output)
+```
+
+#### Extract Metadata
+```python
+reader = PdfReader("document.pdf")
+meta = reader.metadata
+print(f"Title: {meta.title}")
+print(f"Author: {meta.author}")
+print(f"Subject: {meta.subject}")
+print(f"Creator: {meta.creator}")
+```
+
+#### Rotate Pages
+```python
+reader = PdfReader("input.pdf")
+writer = PdfWriter()
+
+page = reader.pages[0]
+page.rotate(90)  # Rotate 90 degrees clockwise
+writer.add_page(page)
+
+with open("rotated.pdf", "wb") as output:
+    writer.write(output)
+```
+
+### pdfplumber - Text and Table Extraction
+
+#### Extract Text with Layout
+```python
+import pdfplumber
+
+with pdfplumber.open("document.pdf") as pdf:
+    for page in pdf.pages:
+        text = page.extract_text()
+        print(text)
+```
+
+#### Extract Tables
+```python
+with pdfplumber.open("document.pdf") as pdf:
+    for i, page in enumerate(pdf.pages):
+        tables = page.extract_tables()
+        for j, table in enumerate(tables):
+            print(f"Table {j+1} on page {i+1}:")
+            for row in table:
+                print(row)
+```
+
+#### Advanced Table Extraction
+```python
+import pandas as pd
+
+with pdfplumber.open("document.pdf") as pdf:
+    all_tables = []
+    for page in pdf.pages:
+        tables = page.extract_tables()
+        for table in tables:
+            if table:  # Check if table is not empty
+                df = pd.DataFrame(table[1:], columns=table[0])
+                all_tables.append(df)
+
+# Combine all tables
+if all_tables:
+    combined_df = pd.concat(all_tables, ignore_index=True)
+    combined_df.to_excel("extracted_tables.xlsx", index=False)
+```
+
+### reportlab - Create PDFs
+
+#### Basic PDF Creation
+```python
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+
+c = canvas.Canvas("hello.pdf", pagesize=letter)
+width, height = letter
+
+# Add text
+c.drawString(100, height - 100, "Hello World!")
+c.drawString(100, height - 120, "This is a PDF created with reportlab")
+
+# Add a line
+c.line(100, height - 140, 400, height - 140)
+
+# Save
+c.save()
+```
+
+#### Create PDF with Multiple Pages
+```python
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak
+from reportlab.lib.styles import getSampleStyleSheet
+
+doc = SimpleDocTemplate("report.pdf", pagesize=letter)
+styles = getSampleStyleSheet()
+story = []
+
+# Add content
+title = Paragraph("Report Title", styles['Title'])
+story.append(title)
+story.append(Spacer(1, 12))
+
+body = Paragraph("This is the body of the report. " * 20, styles['Normal'])
+story.append(body)
+story.append(PageBreak())
+
+# Page 2
+story.append(Paragraph("Page 2", styles['Heading1']))
+story.append(Paragraph("Content for page 2", styles['Normal']))
+
+# Build PDF
+doc.build(story)
+```
+
+## Command-Line Tools
+
+### pdftotext (poppler-utils)
+```bash
+# Extract text
+pdftotext input.pdf output.txt
+
+# Extract text preserving layout
+pdftotext -layout input.pdf output.txt
+
+# Extract specific pages
+pdftotext -f 1 -l 5 input.pdf output.txt  # Pages 1-5
+```
+
+### qpdf
+```bash
+# Merge PDFs
+qpdf --empty --pages file1.pdf file2.pdf -- merged.pdf
+
+# Split pages
+qpdf input.pdf --pages . 1-5 -- pages1-5.pdf
+qpdf input.pdf --pages . 6-10 -- pages6-10.pdf
+
+# Rotate pages
+qpdf input.pdf output.pdf --rotate=+90:1  # Rotate page 1 by 90 degrees
+
+# Remove password
+qpdf --password=mypassword --decrypt encrypted.pdf decrypted.pdf
+```
+
+### pdftk (if available)
+```bash
+# Merge
+pdftk file1.pdf file2.pdf cat output merged.pdf
+
+# Split
+pdftk input.pdf burst
+
+# Rotate
+pdftk input.pdf rotate 1east output rotated.pdf
+```
+
+## Common Tasks
+
+### Extract Text from Scanned PDFs
+```python
+# Requires: pip install pytesseract pdf2image
+import pytesseract
+from pdf2image import convert_from_path
+
+# Convert PDF to images
+images = convert_from_path('scanned.pdf')
+
+# OCR each page
+text = ""
+for i, image in enumerate(images):
+    text += f"Page {i+1}:\n"
+    text += pytesseract.image_to_string(image)
+    text += "\n\n"
+
+print(text)
+```
+
+### Add Watermark
+```python
+from pypdf import PdfReader, PdfWriter
+
+# Create watermark (or load existing)
+watermark = PdfReader("watermark.pdf").pages[0]
+
+# Apply to all pages
+reader = PdfReader("document.pdf")
+writer = PdfWriter()
+
+for page in reader.pages:
+    page.merge_page(watermark)
+    writer.add_page(page)
+
+with open("watermarked.pdf", "wb") as output:
+    writer.write(output)
+```
+
+### Extract Images
+```bash
+# Using pdfimages (poppler-utils)
+pdfimages -j input.pdf output_prefix
+
+# This extracts all images as output_prefix-000.jpg, output_prefix-001.jpg, etc.
+```
+
+### Password Protection
+```python
+from pypdf import PdfReader, PdfWriter
+
+reader = PdfReader("input.pdf")
+writer = PdfWriter()
+
+for page in reader.pages:
+    writer.add_page(page)
+
+# Add password
+writer.encrypt("userpassword", "ownerpassword")
+
+with open("encrypted.pdf", "wb") as output:
+    writer.write(output)
+```
+
+## Quick Reference
+
+| Task | Best Tool | Command/Code |
+|------|-----------|--------------|
+| Merge PDFs | pypdf | `writer.add_page(page)` |
+| Split PDFs | pypdf | One page per file |
+| Extract text | pdfplumber | `page.extract_text()` |
+| Extract tables | pdfplumber | `page.extract_tables()` |
+| Create PDFs | reportlab | Canvas or Platypus |
+| Command line merge | qpdf | `qpdf --empty --pages ...` |
+| OCR scanned PDFs | pytesseract | Convert to image first |
+| Fill PDF forms | pdf-lib or pypdf (see forms.md) | See forms.md |
+
+## Next Steps
+
+- For advanced pypdfium2 usage, see reference.md
+- For JavaScript libraries (pdf-lib), see reference.md
+- If you need to fill out a PDF form, follow the instructions in forms.md
+- For troubleshooting guides, see reference.md

adapters-output/codebuddy/pdf/workflows/pdf.json

@@ -0,0 +1,27 @@
+{
+  "id": "pdf",
+  "name": "PDF Processing Guide",
+  "description": "Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "analyze",
+      "description": "Analyze requirements",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "execute",
+      "description": "Execute skill task",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "output",
+      "description": "Generate output",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/pptx/manifest.json

@@ -0,0 +1,276 @@
+{
+  "name": "pptx",
+  "version": "1.0.0",
+  "description": "Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying or editing content, (3) Working with layouts, (4) Adding comments or speaker notes, or any other presentation tasks",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "pptx",
+      "name": "PPTX creation, editing, and analysis",
+      "description": "Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying or editing content, (3) Working with layouts, (4) Adding comments or speaker notes, or any other presentation tasks",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**Read theme file**",
+          "description": "**Read theme file**: Check `ppt/theme/theme1.xml` for colors (`<a:clrScheme>`) and fonts (`<a:fontScheme>`)",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**Sample slide content**",
+          "description": "**Sample slide content**: Examine `ppt/slides/slide1.xml` for actual font usage (`<a:rPr>`) and colors",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**Search for patterns**",
+          "description": "**Search for patterns**: Use grep to find color (`<a:solidFill>`, `<a:srgbClr>`) and font references across all XML files",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**Consider the subject matter**",
+          "description": "**Consider the subject matter**: What is this presentation about? What tone, industry, or mood does it suggest?",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**Check for branding**",
+          "description": "**Check for branding**: If the user mentions a company/organization, consider their brand colors and identity",
+          "type": "instruction"
+        },
+        {
+          "id": 6,
+          "name": "**Match palette to content**",
+          "description": "**Match palette to content**: Select colors that reflect the subject",
+          "type": "instruction"
+        },
+        {
+          "id": 7,
+          "name": "**State your approach**",
+          "description": "**State your approach**: Explain your design choices before writing code",
+          "type": "instruction"
+        },
+        {
+          "id": 8,
+          "name": "**Classic Blue**",
+          "description": "**Classic Blue**: Deep navy (#1C2833), slate gray (#2E4053), silver (#AAB7B8), off-white (#F4F6F6)",
+          "type": "instruction"
+        },
+        {
+          "id": 9,
+          "name": "**Teal & Coral**",
+          "description": "**Teal & Coral**: Teal (#5EA8A7), deep teal (#277884), coral (#FE4447), white (#FFFFFF)",
+          "type": "instruction"
+        },
+        {
+          "id": 10,
+          "name": "**Bold Red**",
+          "description": "**Bold Red**: Red (#C0392B), bright red (#E74C3C), orange (#F39C12), yellow (#F1C40F), green (#2ECC71)",
+          "type": "instruction"
+        },
+        {
+          "id": 11,
+          "name": "**Warm Blush**",
+          "description": "**Warm Blush**: Mauve (#A49393), blush (#EED6D3), rose (#E8B4B8), cream (#FAF7F2)",
+          "type": "instruction"
+        },
+        {
+          "id": 12,
+          "name": "**Burgundy Luxury**",
+          "description": "**Burgundy Luxury**: Burgundy (#5D1D2E), crimson (#951233), rust (#C15937), gold (#997929)",
+          "type": "instruction"
+        },
+        {
+          "id": 13,
+          "name": "**Deep Purple & Emerald**",
+          "description": "**Deep Purple & Emerald**: Purple (#B165FB), dark blue (#181B24), emerald (#40695B), white (#FFFFFF)",
+          "type": "instruction"
+        },
+        {
+          "id": 14,
+          "name": "**Cream & Forest Green**",
+          "description": "**Cream & Forest Green**: Cream (#FFE1C7), forest green (#40695B), white (#FCFCFC)",
+          "type": "instruction"
+        },
+        {
+          "id": 15,
+          "name": "**Pink & Purple**",
+          "description": "**Pink & Purple**: Pink (#F8275B), coral (#FF574A), rose (#FF737D), purple (#3D2F68)",
+          "type": "instruction"
+        },
+        {
+          "id": 16,
+          "name": "**Lime & Plum**",
+          "description": "**Lime & Plum**: Lime (#C5DE82), plum (#7C3A5F), coral (#FD8C6E), blue-gray (#98ACB5)",
+          "type": "instruction"
+        },
+        {
+          "id": 17,
+          "name": "**Black & Gold**",
+          "description": "**Black & Gold**: Gold (#BF9A4A), black (#000000), cream (#F4F6F6)",
+          "type": "instruction"
+        },
+        {
+          "id": 18,
+          "name": "**Sage & Terracotta**",
+          "description": "**Sage & Terracotta**: Sage (#87A96B), terracotta (#E07A5F), cream (#F4F1DE), charcoal (#2C2C2C)",
+          "type": "instruction"
+        },
+        {
+          "id": 19,
+          "name": "**Charcoal & Red**",
+          "description": "**Charcoal & Red**: Charcoal (#292929), red (#E33737), light gray (#CCCBCB)",
+          "type": "instruction"
+        },
+        {
+          "id": 20,
+          "name": "**Vibrant Orange**",
+          "description": "**Vibrant Orange**: Orange (#F96D00), light gray (#F2F2F2), charcoal (#222831)",
+          "type": "instruction"
+        },
+        {
+          "id": 21,
+          "name": "**Forest Green**",
+          "description": "**Forest Green**: Black (#191A19), green (#4E9F3D), dark green (#1E5128), white (#FFFFFF)",
+          "type": "instruction"
+        },
+        {
+          "id": 22,
+          "name": "**Retro Rainbow**",
+          "description": "**Retro Rainbow**: Purple (#722880), pink (#D72D51), orange (#EB5C18), amber (#F08800), gold (#DEB600)",
+          "type": "instruction"
+        },
+        {
+          "id": 23,
+          "name": "**Vintage Earthy**",
+          "description": "**Vintage Earthy**: Mustard (#E3B448), sage (#CBD18F), forest green (#3A6B35), cream (#F4F1DE)",
+          "type": "instruction"
+        },
+        {
+          "id": 24,
+          "name": "**Coastal Rose**",
+          "description": "**Coastal Rose**: Old rose (#AD7670), beaver (#B49886), eggshell (#F3ECDC), ash gray (#BFD5BE)",
+          "type": "instruction"
+        },
+        {
+          "id": 25,
+          "name": "**Orange & Turquoise**",
+          "description": "**Orange & Turquoise**: Light orange (#FC993E), grayish turquoise (#667C6F), white (#FCFCFC)",
+          "type": "instruction"
+        },
+        {
+          "id": 26,
+          "name": "**MANDATORY - READ ENTIRE FILE**",
+          "description": "**MANDATORY - READ ENTIRE FILE**: Read [`html2pptx.md`](html2pptx.md) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for detailed syntax, critical formatting rules, and best practices before proceeding with presentation creation.",
+          "type": "instruction"
+        },
+        {
+          "id": 27,
+          "name": "Create an HTML file for each slide with proper dimensions (e.g., 720pt × 405pt for 16",
+          "description": "Create an HTML file for each slide with proper dimensions (e.g., 720pt × 405pt for 16:9)",
+          "type": "instruction"
+        },
+        {
+          "id": 28,
+          "name": "Create and run a JavaScript file using the [`html2pptx.js`](scripts/html2pptx.js) library to convert HTML slides to PowerPoint and save the presentation",
+          "description": "Create and run a JavaScript file using the [`html2pptx.js`](scripts/html2pptx.js) library to convert HTML slides to PowerPoint and save the presentation",
+          "type": "instruction"
+        },
+        {
+          "id": 29,
+          "name": "**Visual validation**",
+          "description": "**Visual validation**: Generate thumbnails and inspect for layout issues",
+          "type": "instruction"
+        },
+        {
+          "id": 30,
+          "name": "**MANDATORY - READ ENTIRE FILE**",
+          "description": "**MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~500 lines) completely from start to finish.  **NEVER set any range limits when reading this file.**  Read the full file content for detailed guidance on OOXML structure and editing workflows before any presentation editing.",
+          "type": "instruction"
+        },
+        {
+          "id": 31,
+          "name": "Unpack the presentation",
+          "description": "Unpack the presentation: `python ooxml/scripts/unpack.py <office_file> <output_dir>`",
+          "type": "instruction"
+        },
+        {
+          "id": 32,
+          "name": "Edit the XML files (primarily `ppt/slides/slide{N}.xml` and related files)",
+          "description": "Edit the XML files (primarily `ppt/slides/slide{N}.xml` and related files)",
+          "type": "instruction"
+        },
+        {
+          "id": 33,
+          "name": "**CRITICAL**",
+          "description": "**CRITICAL**: Validate immediately after each edit and fix any validation errors before proceeding: `python ooxml/scripts/validate.py <dir> --original <file>`",
+          "type": "instruction"
+        },
+        {
+          "id": 34,
+          "name": "Pack the final presentation",
+          "description": "Pack the final presentation: `python ooxml/scripts/pack.py <input_directory> <office_file>`",
+          "type": "instruction"
+        },
+        {
+          "id": 35,
+          "name": "**Extract template text AND create visual thumbnail grid**",
+          "description": "**Extract template text AND create visual thumbnail grid**:",
+          "type": "instruction"
+        },
+        {
+          "id": 36,
+          "name": "**Analyze template and save inventory to a file**",
+          "description": "**Analyze template and save inventory to a file**:",
+          "type": "instruction"
+        },
+        {
+          "id": 37,
+          "name": "**Create presentation outline based on template inventory**",
+          "description": "**Create presentation outline based on template inventory**:",
+          "type": "instruction"
+        },
+        {
+          "id": 38,
+          "name": "**Duplicate, reorder, and delete slides using `rearrange.py`**",
+          "description": "**Duplicate, reorder, and delete slides using `rearrange.py`**:",
+          "type": "instruction"
+        },
+        {
+          "id": 39,
+          "name": "**Extract ALL text using the `inventory.py` script**",
+          "description": "**Extract ALL text using the `inventory.py` script**:",
+          "type": "instruction"
+        },
+        {
+          "id": 40,
+          "name": "**Generate replacement text and save the data to a JSON file**",
+          "description": "**Generate replacement text and save the data to a JSON file**",
+          "type": "instruction"
+        },
+        {
+          "id": 41,
+          "name": "**Apply replacements using the `replace.py` script**",
+          "description": "**Apply replacements using the `replace.py` script**",
+          "type": "instruction"
+        },
+        {
+          "id": 42,
+          "name": "**Convert PPTX to PDF**",
+          "description": "**Convert PPTX to PDF**:",
+          "type": "instruction"
+        },
+        {
+          "id": 43,
+          "name": "**Convert PDF pages to JPEG images**",
+          "description": "**Convert PDF pages to JPEG images**:",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/pptx/skills/pptx/SKILL.md

@@ -0,0 +1,484 @@
+---
+name: pptx
+description: "Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying or editing content, (3) Working with layouts, (4) Adding comments or speaker notes, or any other presentation tasks"
+license: Proprietary. LICENSE.txt has complete terms
+---
+
+# PPTX creation, editing, and analysis
+
+## Overview
+
+A user may ask you to create, edit, or analyze the contents of a .pptx file. A .pptx file is essentially a ZIP archive containing XML files and other resources that you can read or edit. You have different tools and workflows available for different tasks.
+
+## Reading and analyzing content
+
+### Text extraction
+If you just need to read the text contents of a presentation, you should convert the document to markdown:
+
+```bash
+# Convert document to markdown
+python -m markitdown path-to-file.pptx
+```
+
+### Raw XML access
+You need raw XML access for: comments, speaker notes, slide layouts, animations, design elements, and complex formatting. For any of these features, you'll need to unpack a presentation and read its raw XML contents.
+
+#### Unpacking a file
+`python ooxml/scripts/unpack.py <office_file> <output_dir>`
+
+**Note**: The unpack.py script is located at `skills/pptx/ooxml/scripts/unpack.py` relative to the project root. If the script doesn't exist at this path, use `find . -name "unpack.py"` to locate it.
+
+#### Key file structures
+* `ppt/presentation.xml` - Main presentation metadata and slide references
+* `ppt/slides/slide{N}.xml` - Individual slide contents (slide1.xml, slide2.xml, etc.)
+* `ppt/notesSlides/notesSlide{N}.xml` - Speaker notes for each slide
+* `ppt/comments/modernComment_*.xml` - Comments for specific slides
+* `ppt/slideLayouts/` - Layout templates for slides
+* `ppt/slideMasters/` - Master slide templates
+* `ppt/theme/` - Theme and styling information
+* `ppt/media/` - Images and other media files
+
+#### Typography and color extraction
+**When given an example design to emulate**: Always analyze the presentation's typography and colors first using the methods below:
+1. **Read theme file**: Check `ppt/theme/theme1.xml` for colors (`<a:clrScheme>`) and fonts (`<a:fontScheme>`)
+2. **Sample slide content**: Examine `ppt/slides/slide1.xml` for actual font usage (`<a:rPr>`) and colors
+3. **Search for patterns**: Use grep to find color (`<a:solidFill>`, `<a:srgbClr>`) and font references across all XML files
+
+## Creating a new PowerPoint presentation **without a template**
+
+When creating a new PowerPoint presentation from scratch, use the **html2pptx** workflow to convert HTML slides to PowerPoint with accurate positioning.
+
+### Design Principles
+
+**CRITICAL**: Before creating any presentation, analyze the content and choose appropriate design elements:
+1. **Consider the subject matter**: What is this presentation about? What tone, industry, or mood does it suggest?
+2. **Check for branding**: If the user mentions a company/organization, consider their brand colors and identity
+3. **Match palette to content**: Select colors that reflect the subject
+4. **State your approach**: Explain your design choices before writing code
+
+**Requirements**:
+- ✅ State your content-informed design approach BEFORE writing code
+- ✅ Use web-safe fonts only: Arial, Helvetica, Times New Roman, Georgia, Courier New, Verdana, Tahoma, Trebuchet MS, Impact
+- ✅ Create clear visual hierarchy through size, weight, and color
+- ✅ Ensure readability: strong contrast, appropriately sized text, clean alignment
+- ✅ Be consistent: repeat patterns, spacing, and visual language across slides
+
+#### Color Palette Selection
+
+**Choosing colors creatively**:
+- **Think beyond defaults**: What colors genuinely match this specific topic? Avoid autopilot choices.
+- **Consider multiple angles**: Topic, industry, mood, energy level, target audience, brand identity (if mentioned)
+- **Be adventurous**: Try unexpected combinations - a healthcare presentation doesn't have to be green, finance doesn't have to be navy
+- **Build your palette**: Pick 3-5 colors that work together (dominant colors + supporting tones + accent)
+- **Ensure contrast**: Text must be clearly readable on backgrounds
+
+**Example color palettes** (use these to spark creativity - choose one, adapt it, or create your own):
+
+1. **Classic Blue**: Deep navy (#1C2833), slate gray (#2E4053), silver (#AAB7B8), off-white (#F4F6F6)
+2. **Teal & Coral**: Teal (#5EA8A7), deep teal (#277884), coral (#FE4447), white (#FFFFFF)
+3. **Bold Red**: Red (#C0392B), bright red (#E74C3C), orange (#F39C12), yellow (#F1C40F), green (#2ECC71)
+4. **Warm Blush**: Mauve (#A49393), blush (#EED6D3), rose (#E8B4B8), cream (#FAF7F2)
+5. **Burgundy Luxury**: Burgundy (#5D1D2E), crimson (#951233), rust (#C15937), gold (#997929)
+6. **Deep Purple & Emerald**: Purple (#B165FB), dark blue (#181B24), emerald (#40695B), white (#FFFFFF)
+7. **Cream & Forest Green**: Cream (#FFE1C7), forest green (#40695B), white (#FCFCFC)
+8. **Pink & Purple**: Pink (#F8275B), coral (#FF574A), rose (#FF737D), purple (#3D2F68)
+9. **Lime & Plum**: Lime (#C5DE82), plum (#7C3A5F), coral (#FD8C6E), blue-gray (#98ACB5)
+10. **Black & Gold**: Gold (#BF9A4A), black (#000000), cream (#F4F6F6)
+11. **Sage & Terracotta**: Sage (#87A96B), terracotta (#E07A5F), cream (#F4F1DE), charcoal (#2C2C2C)
+12. **Charcoal & Red**: Charcoal (#292929), red (#E33737), light gray (#CCCBCB)
+13. **Vibrant Orange**: Orange (#F96D00), light gray (#F2F2F2), charcoal (#222831)
+14. **Forest Green**: Black (#191A19), green (#4E9F3D), dark green (#1E5128), white (#FFFFFF)
+15. **Retro Rainbow**: Purple (#722880), pink (#D72D51), orange (#EB5C18), amber (#F08800), gold (#DEB600)
+16. **Vintage Earthy**: Mustard (#E3B448), sage (#CBD18F), forest green (#3A6B35), cream (#F4F1DE)
+17. **Coastal Rose**: Old rose (#AD7670), beaver (#B49886), eggshell (#F3ECDC), ash gray (#BFD5BE)
+18. **Orange & Turquoise**: Light orange (#FC993E), grayish turquoise (#667C6F), white (#FCFCFC)
+
+#### Visual Details Options
+
+**Geometric Patterns**:
+- Diagonal section dividers instead of horizontal
+- Asymmetric column widths (30/70, 40/60, 25/75)
+- Rotated text headers at 90° or 270°
+- Circular/hexagonal frames for images
+- Triangular accent shapes in corners
+- Overlapping shapes for depth
+
+**Border & Frame Treatments**:
+- Thick single-color borders (10-20pt) on one side only
+- Double-line borders with contrasting colors
+- Corner brackets instead of full frames
+- L-shaped borders (top+left or bottom+right)
+- Underline accents beneath headers (3-5pt thick)
+
+**Typography Treatments**:
+- Extreme size contrast (72pt headlines vs 11pt body)
+- All-caps headers with wide letter spacing
+- Numbered sections in oversized display type
+- Monospace (Courier New) for data/stats/technical content
+- Condensed fonts (Arial Narrow) for dense information
+- Outlined text for emphasis
+
+**Chart & Data Styling**:
+- Monochrome charts with single accent color for key data
+- Horizontal bar charts instead of vertical
+- Dot plots instead of bar charts
+- Minimal gridlines or none at all
+- Data labels directly on elements (no legends)
+- Oversized numbers for key metrics
+
+**Layout Innovations**:
+- Full-bleed images with text overlays
+- Sidebar column (20-30% width) for navigation/context
+- Modular grid systems (3×3, 4×4 blocks)
+- Z-pattern or F-pattern content flow
+- Floating text boxes over colored shapes
+- Magazine-style multi-column layouts
+
+**Background Treatments**:
+- Solid color blocks occupying 40-60% of slide
+- Gradient fills (vertical or diagonal only)
+- Split backgrounds (two colors, diagonal or vertical)
+- Edge-to-edge color bands
+- Negative space as a design element
+
+### Layout Tips
+**When creating slides with charts or tables:**
+- **Two-column layout (PREFERRED)**: Use a header spanning the full width, then two columns below - text/bullets in one column and the featured content in the other. This provides better balance and makes charts/tables more readable. Use flexbox with unequal column widths (e.g., 40%/60% split) to optimize space for each content type.
+- **Full-slide layout**: Let the featured content (chart/table) take up the entire slide for maximum impact and readability
+- **NEVER vertically stack**: Do not place charts/tables below text in a single column - this causes poor readability and layout issues
+
+### Workflow
+1. **MANDATORY - READ ENTIRE FILE**: Read [`html2pptx.md`](html2pptx.md) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for detailed syntax, critical formatting rules, and best practices before proceeding with presentation creation.
+2. Create an HTML file for each slide with proper dimensions (e.g., 720pt × 405pt for 16:9)
+   - Use `<p>`, `<h1>`-`<h6>`, `<ul>`, `<ol>` for all text content
+   - Use `class="placeholder"` for areas where charts/tables will be added (render with gray background for visibility)
+   - **CRITICAL**: Rasterize gradients and icons as PNG images FIRST using Sharp, then reference in HTML
+   - **LAYOUT**: For slides with charts/tables/images, use either full-slide layout or two-column layout for better readability
+3. Create and run a JavaScript file using the [`html2pptx.js`](scripts/html2pptx.js) library to convert HTML slides to PowerPoint and save the presentation
+   - Use the `html2pptx()` function to process each HTML file
+   - Add charts and tables to placeholder areas using PptxGenJS API
+   - Save the presentation using `pptx.writeFile()`
+4. **Visual validation**: Generate thumbnails and inspect for layout issues
+   - Create thumbnail grid: `python scripts/thumbnail.py output.pptx workspace/thumbnails --cols 4`
+   - Read and carefully examine the thumbnail image for:
+     - **Text cutoff**: Text being cut off by header bars, shapes, or slide edges
+     - **Text overlap**: Text overlapping with other text or shapes
+     - **Positioning issues**: Content too close to slide boundaries or other elements
+     - **Contrast issues**: Insufficient contrast between text and backgrounds
+   - If issues found, adjust HTML margins/spacing/colors and regenerate the presentation
+   - Repeat until all slides are visually correct
+
+## Editing an existing PowerPoint presentation
+
+When edit slides in an existing PowerPoint presentation, you need to work with the raw Office Open XML (OOXML) format. This involves unpacking the .pptx file, editing the XML content, and repacking it.
+
+### Workflow
+1. **MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~500 lines) completely from start to finish.  **NEVER set any range limits when reading this file.**  Read the full file content for detailed guidance on OOXML structure and editing workflows before any presentation editing.
+2. Unpack the presentation: `python ooxml/scripts/unpack.py <office_file> <output_dir>`
+3. Edit the XML files (primarily `ppt/slides/slide{N}.xml` and related files)
+4. **CRITICAL**: Validate immediately after each edit and fix any validation errors before proceeding: `python ooxml/scripts/validate.py <dir> --original <file>`
+5. Pack the final presentation: `python ooxml/scripts/pack.py <input_directory> <office_file>`
+
+## Creating a new PowerPoint presentation **using a template**
+
+When you need to create a presentation that follows an existing template's design, you'll need to duplicate and re-arrange template slides before then replacing placeholder context.
+
+### Workflow
+1. **Extract template text AND create visual thumbnail grid**:
+   * Extract text: `python -m markitdown template.pptx > template-content.md`
+   * Read `template-content.md`: Read the entire file to understand the contents of the template presentation. **NEVER set any range limits when reading this file.**
+   * Create thumbnail grids: `python scripts/thumbnail.py template.pptx`
+   * See [Creating Thumbnail Grids](#creating-thumbnail-grids) section for more details
+
+2. **Analyze template and save inventory to a file**:
+   * **Visual Analysis**: Review thumbnail grid(s) to understand slide layouts, design patterns, and visual structure
+   * Create and save a template inventory file at `template-inventory.md` containing:
+     ```markdown
+     # Template Inventory Analysis
+     **Total Slides: [count]**
+     **IMPORTANT: Slides are 0-indexed (first slide = 0, last slide = count-1)**
+
+     ## [Category Name]
+     - Slide 0: [Layout code if available] - Description/purpose
+     - Slide 1: [Layout code] - Description/purpose
+     - Slide 2: [Layout code] - Description/purpose
+     [... EVERY slide must be listed individually with its index ...]
+     ```
+   * **Using the thumbnail grid**: Reference the visual thumbnails to identify:
+     - Layout patterns (title slides, content layouts, section dividers)
+     - Image placeholder locations and counts
+     - Design consistency across slide groups
+     - Visual hierarchy and structure
+   * This inventory file is REQUIRED for selecting appropriate templates in the next step
+
+3. **Create presentation outline based on template inventory**:
+   * Review available templates from step 2.
+   * Choose an intro or title template for the first slide. This should be one of the first templates.
+   * Choose safe, text-based layouts for the other slides.
+   * **CRITICAL: Match layout structure to actual content**:
+     - Single-column layouts: Use for unified narrative or single topic
+     - Two-column layouts: Use ONLY when you have exactly 2 distinct items/concepts
+     - Three-column layouts: Use ONLY when you have exactly 3 distinct items/concepts
+     - Image + text layouts: Use ONLY when you have actual images to insert
+     - Quote layouts: Use ONLY for actual quotes from people (with attribution), never for emphasis
+     - Never use layouts with more placeholders than you have content
+     - If you have 2 items, don't force them into a 3-column layout
+     - If you have 4+ items, consider breaking into multiple slides or using a list format
+   * Count your actual content pieces BEFORE selecting the layout
+   * Verify each placeholder in the chosen layout will be filled with meaningful content
+   * Select one option representing the **best** layout for each content section.
+   * Save `outline.md` with content AND template mapping that leverages available designs
+   * Example template mapping:
+      ```
+      # Template slides to use (0-based indexing)
+      # WARNING: Verify indices are within range! Template with 73 slides has indices 0-72
+      # Mapping: slide numbers from outline -> template slide indices
+      template_mapping = [
+          0,   # Use slide 0 (Title/Cover)
+          34,  # Use slide 34 (B1: Title and body)
+          34,  # Use slide 34 again (duplicate for second B1)
+          50,  # Use slide 50 (E1: Quote)
+          54,  # Use slide 54 (F2: Closing + Text)
+      ]
+      ```
+
+4. **Duplicate, reorder, and delete slides using `rearrange.py`**:
+   * Use the `scripts/rearrange.py` script to create a new presentation with slides in the desired order:
+     ```bash
+     python scripts/rearrange.py template.pptx working.pptx 0,34,34,50,52
+     ```
+   * The script handles duplicating repeated slides, deleting unused slides, and reordering automatically
+   * Slide indices are 0-based (first slide is 0, second is 1, etc.)
+   * The same slide index can appear multiple times to duplicate that slide
+
+5. **Extract ALL text using the `inventory.py` script**:
+   * **Run inventory extraction**:
+     ```bash
+     python scripts/inventory.py working.pptx text-inventory.json
+     ```
+   * **Read text-inventory.json**: Read the entire text-inventory.json file to understand all shapes and their properties. **NEVER set any range limits when reading this file.**
+
+   * The inventory JSON structure:
+      ```json
+        {
+          "slide-0": {
+            "shape-0": {
+              "placeholder_type": "TITLE",  // or null for non-placeholders
+              "left": 1.5,                  // position in inches
+              "top": 2.0,
+              "width": 7.5,
+              "height": 1.2,
+              "paragraphs": [
+                {
+                  "text": "Paragraph text",
+                  // Optional properties (only included when non-default):
+                  "bullet": true,           // explicit bullet detected
+                  "level": 0,               // only included when bullet is true
+                  "alignment": "CENTER",    // CENTER, RIGHT (not LEFT)
+                  "space_before": 10.0,     // space before paragraph in points
+                  "space_after": 6.0,       // space after paragraph in points
+                  "line_spacing": 22.4,     // line spacing in points
+                  "font_name": "Arial",     // from first run
+                  "font_size": 14.0,        // in points
+                  "bold": true,
+                  "italic": false,
+                  "underline": false,
+                  "color": "FF0000"         // RGB color
+                }
+              ]
+            }
+          }
+        }
+      ```
+
+   * Key features:
+     - **Slides**: Named as "slide-0", "slide-1", etc.
+     - **Shapes**: Ordered by visual position (top-to-bottom, left-to-right) as "shape-0", "shape-1", etc.
+     - **Placeholder types**: TITLE, CENTER_TITLE, SUBTITLE, BODY, OBJECT, or null
+     - **Default font size**: `default_font_size` in points extracted from layout placeholders (when available)
+     - **Slide numbers are filtered**: Shapes with SLIDE_NUMBER placeholder type are automatically excluded from inventory
+     - **Bullets**: When `bullet: true`, `level` is always included (even if 0)
+     - **Spacing**: `space_before`, `space_after`, and `line_spacing` in points (only included when set)
+     - **Colors**: `color` for RGB (e.g., "FF0000"), `theme_color` for theme colors (e.g., "DARK_1")
+     - **Properties**: Only non-default values are included in the output
+
+6. **Generate replacement text and save the data to a JSON file**
+   Based on the text inventory from the previous step:
+   - **CRITICAL**: First verify which shapes exist in the inventory - only reference shapes that are actually present
+   - **VALIDATION**: The replace.py script will validate that all shapes in your replacement JSON exist in the inventory
+     - If you reference a non-existent shape, you'll get an error showing available shapes
+     - If you reference a non-existent slide, you'll get an error indicating the slide doesn't exist
+     - All validation errors are shown at once before the script exits
+   - **IMPORTANT**: The replace.py script uses inventory.py internally to identify ALL text shapes
+   - **AUTOMATIC CLEARING**: ALL text shapes from the inventory will be cleared unless you provide "paragraphs" for them
+   - Add a "paragraphs" field to shapes that need content (not "replacement_paragraphs")
+   - Shapes without "paragraphs" in the replacement JSON will have their text cleared automatically
+   - Paragraphs with bullets will be automatically left aligned. Don't set the `alignment` property on when `"bullet": true`
+   - Generate appropriate replacement content for placeholder text
+   - Use shape size to determine appropriate content length
+   - **CRITICAL**: Include paragraph properties from the original inventory - don't just provide text
+   - **IMPORTANT**: When bullet: true, do NOT include bullet symbols (•, -, *) in text - they're added automatically
+   - **ESSENTIAL FORMATTING RULES**:
+     - Headers/titles should typically have `"bold": true`
+     - List items should have `"bullet": true, "level": 0` (level is required when bullet is true)
+     - Preserve any alignment properties (e.g., `"alignment": "CENTER"` for centered text)
+     - Include font properties when different from default (e.g., `"font_size": 14.0`, `"font_name": "Lora"`)
+     - Colors: Use `"color": "FF0000"` for RGB or `"theme_color": "DARK_1"` for theme colors
+     - The replacement script expects **properly formatted paragraphs**, not just text strings
+     - **Overlapping shapes**: Prefer shapes with larger default_font_size or more appropriate placeholder_type
+   - Save the updated inventory with replacements to `replacement-text.json`
+   - **WARNING**: Different template layouts have different shape counts - always check the actual inventory before creating replacements
+
+   Example paragraphs field showing proper formatting:
+   ```json
+   "paragraphs": [
+     {
+       "text": "New presentation title text",
+       "alignment": "CENTER",
+       "bold": true
+     },
+     {
+       "text": "Section Header",
+       "bold": true
+     },
+     {
+       "text": "First bullet point without bullet symbol",
+       "bullet": true,
+       "level": 0
+     },
+     {
+       "text": "Red colored text",
+       "color": "FF0000"
+     },
+     {
+       "text": "Theme colored text",
+       "theme_color": "DARK_1"
+     },
+     {
+       "text": "Regular paragraph text without special formatting"
+     }
+   ]
+   ```
+
+   **Shapes not listed in the replacement JSON are automatically cleared**:
+   ```json
+   {
+     "slide-0": {
+       "shape-0": {
+         "paragraphs": [...] // This shape gets new text
+       }
+       // shape-1 and shape-2 from inventory will be cleared automatically
+     }
+   }
+   ```
+
+   **Common formatting patterns for presentations**:
+   - Title slides: Bold text, sometimes centered
+   - Section headers within slides: Bold text
+   - Bullet lists: Each item needs `"bullet": true, "level": 0`
+   - Body text: Usually no special properties needed
+   - Quotes: May have special alignment or font properties
+
+7. **Apply replacements using the `replace.py` script**
+   ```bash
+   python scripts/replace.py working.pptx replacement-text.json output.pptx
+   ```
+
+   The script will:
+   - First extract the inventory of ALL text shapes using functions from inventory.py
+   - Validate that all shapes in the replacement JSON exist in the inventory
+   - Clear text from ALL shapes identified in the inventory
+   - Apply new text only to shapes with "paragraphs" defined in the replacement JSON
+   - Preserve formatting by applying paragraph properties from the JSON
+   - Handle bullets, alignment, font properties, and colors automatically
+   - Save the updated presentation
+
+   Example validation errors:
+   ```
+   ERROR: Invalid shapes in replacement JSON:
+     - Shape 'shape-99' not found on 'slide-0'. Available shapes: shape-0, shape-1, shape-4
+     - Slide 'slide-999' not found in inventory
+   ```
+
+   ```
+   ERROR: Replacement text made overflow worse in these shapes:
+     - slide-0/shape-2: overflow worsened by 1.25" (was 0.00", now 1.25")
+   ```
+
+## Creating Thumbnail Grids
+
+To create visual thumbnail grids of PowerPoint slides for quick analysis and reference:
+
+```bash
+python scripts/thumbnail.py template.pptx [output_prefix]
+```
+
+**Features**:
+- Creates: `thumbnails.jpg` (or `thumbnails-1.jpg`, `thumbnails-2.jpg`, etc. for large decks)
+- Default: 5 columns, max 30 slides per grid (5×6)
+- Custom prefix: `python scripts/thumbnail.py template.pptx my-grid`
+  - Note: The output prefix should include the path if you want output in a specific directory (e.g., `workspace/my-grid`)
+- Adjust columns: `--cols 4` (range: 3-6, affects slides per grid)
+- Grid limits: 3 cols = 12 slides/grid, 4 cols = 20, 5 cols = 30, 6 cols = 42
+- Slides are zero-indexed (Slide 0, Slide 1, etc.)
+
+**Use cases**:
+- Template analysis: Quickly understand slide layouts and design patterns
+- Content review: Visual overview of entire presentation
+- Navigation reference: Find specific slides by their visual appearance
+- Quality check: Verify all slides are properly formatted
+
+**Examples**:
+```bash
+# Basic usage
+python scripts/thumbnail.py presentation.pptx
+
+# Combine options: custom name, columns
+python scripts/thumbnail.py template.pptx analysis --cols 4
+```
+
+## Converting Slides to Images
+
+To visually analyze PowerPoint slides, convert them to images using a two-step process:
+
+1. **Convert PPTX to PDF**:
+   ```bash
+   soffice --headless --convert-to pdf template.pptx
+   ```
+
+2. **Convert PDF pages to JPEG images**:
+   ```bash
+   pdftoppm -jpeg -r 150 template.pdf slide
+   ```
+   This creates files like `slide-1.jpg`, `slide-2.jpg`, etc.
+
+Options:
+- `-r 150`: Sets resolution to 150 DPI (adjust for quality/size balance)
+- `-jpeg`: Output JPEG format (use `-png` for PNG if preferred)
+- `-f N`: First page to convert (e.g., `-f 2` starts from page 2)
+- `-l N`: Last page to convert (e.g., `-l 5` stops at page 5)
+- `slide`: Prefix for output files
+
+Example for specific range:
+```bash
+pdftoppm -jpeg -r 150 -f 2 -l 5 template.pdf slide  # Converts only pages 2-5
+```
+
+## Code Style Guidelines
+**IMPORTANT**: When generating code for PPTX operations:
+- Write concise code
+- Avoid verbose variable names and redundant operations
+- Avoid unnecessary print statements
+
+## Dependencies
+
+Required dependencies (should already be installed):
+
+- **markitdown**: `pip install "markitdown[pptx]"` (for text extraction from presentations)
+- **pptxgenjs**: `npm install -g pptxgenjs` (for creating presentations via html2pptx)
+- **playwright**: `npm install -g playwright` (for HTML rendering in html2pptx)
+- **react-icons**: `npm install -g react-icons react react-dom` (for icons)
+- **sharp**: `npm install -g sharp` (for SVG rasterization and image processing)
+- **LibreOffice**: `sudo apt-get install libreoffice` (for PDF conversion)
+- **Poppler**: `sudo apt-get install poppler-utils` (for pdftoppm to convert PDF to images)
+- **defusedxml**: `pip install defusedxml` (for secure XML parsing)

adapters-output/codebuddy/pptx/workflows/pptx.json

@@ -0,0 +1,267 @@
+{
+  "id": "pptx",
+  "name": "PPTX creation, editing, and analysis",
+  "description": "Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying or editing content, (3) Working with layouts, (4) Adding comments or speaker notes, or any other presentation tasks",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**Read theme file**",
+      "description": "**Read theme file**: Check `ppt/theme/theme1.xml` for colors (`<a:clrScheme>`) and fonts (`<a:fontScheme>`)",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**Sample slide content**",
+      "description": "**Sample slide content**: Examine `ppt/slides/slide1.xml` for actual font usage (`<a:rPr>`) and colors",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**Search for patterns**",
+      "description": "**Search for patterns**: Use grep to find color (`<a:solidFill>`, `<a:srgbClr>`) and font references across all XML files",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**Consider the subject matter**",
+      "description": "**Consider the subject matter**: What is this presentation about? What tone, industry, or mood does it suggest?",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**Check for branding**",
+      "description": "**Check for branding**: If the user mentions a company/organization, consider their brand colors and identity",
+      "type": "instruction"
+    },
+    {
+      "id": 6,
+      "name": "**Match palette to content**",
+      "description": "**Match palette to content**: Select colors that reflect the subject",
+      "type": "instruction"
+    },
+    {
+      "id": 7,
+      "name": "**State your approach**",
+      "description": "**State your approach**: Explain your design choices before writing code",
+      "type": "instruction"
+    },
+    {
+      "id": 8,
+      "name": "**Classic Blue**",
+      "description": "**Classic Blue**: Deep navy (#1C2833), slate gray (#2E4053), silver (#AAB7B8), off-white (#F4F6F6)",
+      "type": "instruction"
+    },
+    {
+      "id": 9,
+      "name": "**Teal & Coral**",
+      "description": "**Teal & Coral**: Teal (#5EA8A7), deep teal (#277884), coral (#FE4447), white (#FFFFFF)",
+      "type": "instruction"
+    },
+    {
+      "id": 10,
+      "name": "**Bold Red**",
+      "description": "**Bold Red**: Red (#C0392B), bright red (#E74C3C), orange (#F39C12), yellow (#F1C40F), green (#2ECC71)",
+      "type": "instruction"
+    },
+    {
+      "id": 11,
+      "name": "**Warm Blush**",
+      "description": "**Warm Blush**: Mauve (#A49393), blush (#EED6D3), rose (#E8B4B8), cream (#FAF7F2)",
+      "type": "instruction"
+    },
+    {
+      "id": 12,
+      "name": "**Burgundy Luxury**",
+      "description": "**Burgundy Luxury**: Burgundy (#5D1D2E), crimson (#951233), rust (#C15937), gold (#997929)",
+      "type": "instruction"
+    },
+    {
+      "id": 13,
+      "name": "**Deep Purple & Emerald**",
+      "description": "**Deep Purple & Emerald**: Purple (#B165FB), dark blue (#181B24), emerald (#40695B), white (#FFFFFF)",
+      "type": "instruction"
+    },
+    {
+      "id": 14,
+      "name": "**Cream & Forest Green**",
+      "description": "**Cream & Forest Green**: Cream (#FFE1C7), forest green (#40695B), white (#FCFCFC)",
+      "type": "instruction"
+    },
+    {
+      "id": 15,
+      "name": "**Pink & Purple**",
+      "description": "**Pink & Purple**: Pink (#F8275B), coral (#FF574A), rose (#FF737D), purple (#3D2F68)",
+      "type": "instruction"
+    },
+    {
+      "id": 16,
+      "name": "**Lime & Plum**",
+      "description": "**Lime & Plum**: Lime (#C5DE82), plum (#7C3A5F), coral (#FD8C6E), blue-gray (#98ACB5)",
+      "type": "instruction"
+    },
+    {
+      "id": 17,
+      "name": "**Black & Gold**",
+      "description": "**Black & Gold**: Gold (#BF9A4A), black (#000000), cream (#F4F6F6)",
+      "type": "instruction"
+    },
+    {
+      "id": 18,
+      "name": "**Sage & Terracotta**",
+      "description": "**Sage & Terracotta**: Sage (#87A96B), terracotta (#E07A5F), cream (#F4F1DE), charcoal (#2C2C2C)",
+      "type": "instruction"
+    },
+    {
+      "id": 19,
+      "name": "**Charcoal & Red**",
+      "description": "**Charcoal & Red**: Charcoal (#292929), red (#E33737), light gray (#CCCBCB)",
+      "type": "instruction"
+    },
+    {
+      "id": 20,
+      "name": "**Vibrant Orange**",
+      "description": "**Vibrant Orange**: Orange (#F96D00), light gray (#F2F2F2), charcoal (#222831)",
+      "type": "instruction"
+    },
+    {
+      "id": 21,
+      "name": "**Forest Green**",
+      "description": "**Forest Green**: Black (#191A19), green (#4E9F3D), dark green (#1E5128), white (#FFFFFF)",
+      "type": "instruction"
+    },
+    {
+      "id": 22,
+      "name": "**Retro Rainbow**",
+      "description": "**Retro Rainbow**: Purple (#722880), pink (#D72D51), orange (#EB5C18), amber (#F08800), gold (#DEB600)",
+      "type": "instruction"
+    },
+    {
+      "id": 23,
+      "name": "**Vintage Earthy**",
+      "description": "**Vintage Earthy**: Mustard (#E3B448), sage (#CBD18F), forest green (#3A6B35), cream (#F4F1DE)",
+      "type": "instruction"
+    },
+    {
+      "id": 24,
+      "name": "**Coastal Rose**",
+      "description": "**Coastal Rose**: Old rose (#AD7670), beaver (#B49886), eggshell (#F3ECDC), ash gray (#BFD5BE)",
+      "type": "instruction"
+    },
+    {
+      "id": 25,
+      "name": "**Orange & Turquoise**",
+      "description": "**Orange & Turquoise**: Light orange (#FC993E), grayish turquoise (#667C6F), white (#FCFCFC)",
+      "type": "instruction"
+    },
+    {
+      "id": 26,
+      "name": "**MANDATORY - READ ENTIRE FILE**",
+      "description": "**MANDATORY - READ ENTIRE FILE**: Read [`html2pptx.md`](html2pptx.md) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for detailed syntax, critical formatting rules, and best practices before proceeding with presentation creation.",
+      "type": "instruction"
+    },
+    {
+      "id": 27,
+      "name": "Create an HTML file for each slide with proper dimensions (e.g., 720pt × 405pt for 16",
+      "description": "Create an HTML file for each slide with proper dimensions (e.g., 720pt × 405pt for 16:9)",
+      "type": "instruction"
+    },
+    {
+      "id": 28,
+      "name": "Create and run a JavaScript file using the [`html2pptx.js`](scripts/html2pptx.js) library to convert HTML slides to PowerPoint and save the presentation",
+      "description": "Create and run a JavaScript file using the [`html2pptx.js`](scripts/html2pptx.js) library to convert HTML slides to PowerPoint and save the presentation",
+      "type": "instruction"
+    },
+    {
+      "id": 29,
+      "name": "**Visual validation**",
+      "description": "**Visual validation**: Generate thumbnails and inspect for layout issues",
+      "type": "instruction"
+    },
+    {
+      "id": 30,
+      "name": "**MANDATORY - READ ENTIRE FILE**",
+      "description": "**MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~500 lines) completely from start to finish.  **NEVER set any range limits when reading this file.**  Read the full file content for detailed guidance on OOXML structure and editing workflows before any presentation editing.",
+      "type": "instruction"
+    },
+    {
+      "id": 31,
+      "name": "Unpack the presentation",
+      "description": "Unpack the presentation: `python ooxml/scripts/unpack.py <office_file> <output_dir>`",
+      "type": "instruction"
+    },
+    {
+      "id": 32,
+      "name": "Edit the XML files (primarily `ppt/slides/slide{N}.xml` and related files)",
+      "description": "Edit the XML files (primarily `ppt/slides/slide{N}.xml` and related files)",
+      "type": "instruction"
+    },
+    {
+      "id": 33,
+      "name": "**CRITICAL**",
+      "description": "**CRITICAL**: Validate immediately after each edit and fix any validation errors before proceeding: `python ooxml/scripts/validate.py <dir> --original <file>`",
+      "type": "instruction"
+    },
+    {
+      "id": 34,
+      "name": "Pack the final presentation",
+      "description": "Pack the final presentation: `python ooxml/scripts/pack.py <input_directory> <office_file>`",
+      "type": "instruction"
+    },
+    {
+      "id": 35,
+      "name": "**Extract template text AND create visual thumbnail grid**",
+      "description": "**Extract template text AND create visual thumbnail grid**:",
+      "type": "instruction"
+    },
+    {
+      "id": 36,
+      "name": "**Analyze template and save inventory to a file**",
+      "description": "**Analyze template and save inventory to a file**:",
+      "type": "instruction"
+    },
+    {
+      "id": 37,
+      "name": "**Create presentation outline based on template inventory**",
+      "description": "**Create presentation outline based on template inventory**:",
+      "type": "instruction"
+    },
+    {
+      "id": 38,
+      "name": "**Duplicate, reorder, and delete slides using `rearrange.py`**",
+      "description": "**Duplicate, reorder, and delete slides using `rearrange.py`**:",
+      "type": "instruction"
+    },
+    {
+      "id": 39,
+      "name": "**Extract ALL text using the `inventory.py` script**",
+      "description": "**Extract ALL text using the `inventory.py` script**:",
+      "type": "instruction"
+    },
+    {
+      "id": 40,
+      "name": "**Generate replacement text and save the data to a JSON file**",
+      "description": "**Generate replacement text and save the data to a JSON file**",
+      "type": "instruction"
+    },
+    {
+      "id": 41,
+      "name": "**Apply replacements using the `replace.py` script**",
+      "description": "**Apply replacements using the `replace.py` script**",
+      "type": "instruction"
+    },
+    {
+      "id": 42,
+      "name": "**Convert PPTX to PDF**",
+      "description": "**Convert PPTX to PDF**:",
+      "type": "instruction"
+    },
+    {
+      "id": 43,
+      "name": "**Convert PDF pages to JPEG images**",
+      "description": "**Convert PDF pages to JPEG images**:",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/skill-creator/manifest.json

@@ -0,0 +1,180 @@
+{
+  "name": "skill-creator",
+  "version": "1.0.0",
+  "description": "Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "skill-creator",
+      "name": "Skill Creator",
+      "description": "Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "Specialized workflows - Multi-step procedures for specific domains",
+          "description": "Specialized workflows - Multi-step procedures for specific domains",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "Tool integrations - Instructions for working with specific file formats or APIs",
+          "description": "Tool integrations - Instructions for working with specific file formats or APIs",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "Domain expertise - Company-specific knowledge, schemas, business logic",
+          "description": "Domain expertise - Company-specific knowledge, schemas, business logic",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "Bundled resources - Scripts, references, and assets for complex and repetitive tasks",
+          "description": "Bundled resources - Scripts, references, and assets for complex and repetitive tasks",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**Metadata (name + description)** - Always in context (~100 words)",
+          "description": "**Metadata (name + description)** - Always in context (~100 words)",
+          "type": "instruction"
+        },
+        {
+          "id": 6,
+          "name": "**SKILL.md body** - When skill triggers (<5k words)",
+          "description": "**SKILL.md body** - When skill triggers (<5k words)",
+          "type": "instruction"
+        },
+        {
+          "id": 7,
+          "name": "**Bundled resources** - As needed by Claude (Unlimited because scripts can be executed without reading into context window)",
+          "description": "**Bundled resources** - As needed by Claude (Unlimited because scripts can be executed without reading into context window)",
+          "type": "instruction"
+        },
+        {
+          "id": 8,
+          "name": "Understand the skill with concrete examples",
+          "description": "Understand the skill with concrete examples",
+          "type": "instruction"
+        },
+        {
+          "id": 9,
+          "name": "Plan reusable skill contents (scripts, references, assets)",
+          "description": "Plan reusable skill contents (scripts, references, assets)",
+          "type": "instruction"
+        },
+        {
+          "id": 10,
+          "name": "Initialize the skill (run init_skill.py)",
+          "description": "Initialize the skill (run init_skill.py)",
+          "type": "instruction"
+        },
+        {
+          "id": 11,
+          "name": "Edit the skill (implement resources and write SKILL.md)",
+          "description": "Edit the skill (implement resources and write SKILL.md)",
+          "type": "instruction"
+        },
+        {
+          "id": 12,
+          "name": "Package the skill (run package_skill.py)",
+          "description": "Package the skill (run package_skill.py)",
+          "type": "instruction"
+        },
+        {
+          "id": 13,
+          "name": "Iterate based on real usage",
+          "description": "Iterate based on real usage",
+          "type": "instruction"
+        },
+        {
+          "id": 14,
+          "name": "Considering how to execute on the example from scratch",
+          "description": "Considering how to execute on the example from scratch",
+          "type": "instruction"
+        },
+        {
+          "id": 15,
+          "name": "Identifying what scripts, references, and assets would be helpful when executing these workflows repeatedly",
+          "description": "Identifying what scripts, references, and assets would be helpful when executing these workflows repeatedly",
+          "type": "instruction"
+        },
+        {
+          "id": 16,
+          "name": "Rotating a PDF requires re-writing the same code each time",
+          "description": "Rotating a PDF requires re-writing the same code each time",
+          "type": "instruction"
+        },
+        {
+          "id": 17,
+          "name": "A `scripts/rotate_pdf.py` script would be helpful to store in the skill",
+          "description": "A `scripts/rotate_pdf.py` script would be helpful to store in the skill",
+          "type": "instruction"
+        },
+        {
+          "id": 18,
+          "name": "Writing a frontend webapp requires the same boilerplate HTML/React each time",
+          "description": "Writing a frontend webapp requires the same boilerplate HTML/React each time",
+          "type": "instruction"
+        },
+        {
+          "id": 19,
+          "name": "An `assets/hello-world/` template containing the boilerplate HTML/React project files would be helpful to store in the skill",
+          "description": "An `assets/hello-world/` template containing the boilerplate HTML/React project files would be helpful to store in the skill",
+          "type": "instruction"
+        },
+        {
+          "id": 20,
+          "name": "Querying BigQuery requires re-discovering the table schemas and relationships each time",
+          "description": "Querying BigQuery requires re-discovering the table schemas and relationships each time",
+          "type": "instruction"
+        },
+        {
+          "id": 21,
+          "name": "A `references/schema.md` file documenting the table schemas would be helpful to store in the skill",
+          "description": "A `references/schema.md` file documenting the table schemas would be helpful to store in the skill",
+          "type": "instruction"
+        },
+        {
+          "id": 22,
+          "name": "**Validate** the skill automatically, checking",
+          "description": "**Validate** the skill automatically, checking:",
+          "type": "instruction"
+        },
+        {
+          "id": 23,
+          "name": "**Package** the skill if validation passes, creating a .skill file named after the skill (e.g., `my-skill.skill`) that includes all files and maintains the proper directory structure for distribution. The .skill file is a zip file with a .skill extension.",
+          "description": "**Package** the skill if validation passes, creating a .skill file named after the skill (e.g., `my-skill.skill`) that includes all files and maintains the proper directory structure for distribution. The .skill file is a zip file with a .skill extension.",
+          "type": "instruction"
+        },
+        {
+          "id": 24,
+          "name": "Use the skill on real tasks",
+          "description": "Use the skill on real tasks",
+          "type": "instruction"
+        },
+        {
+          "id": 25,
+          "name": "Notice struggles or inefficiencies",
+          "description": "Notice struggles or inefficiencies",
+          "type": "instruction"
+        },
+        {
+          "id": 26,
+          "name": "Identify how SKILL.md or bundled resources should be updated",
+          "description": "Identify how SKILL.md or bundled resources should be updated",
+          "type": "instruction"
+        },
+        {
+          "id": 27,
+          "name": "Implement changes and test again",
+          "description": "Implement changes and test again",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/skill-creator/skills/skill-creator/SKILL.md

@@ -0,0 +1,356 @@
+---
+name: skill-creator
+description: Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.
+license: Complete terms in LICENSE.txt
+---
+
+# Skill Creator
+
+This skill provides guidance for creating effective skills.
+
+## About Skills
+
+Skills are modular, self-contained packages that extend Claude's capabilities by providing
+specialized knowledge, workflows, and tools. Think of them as "onboarding guides" for specific
+domains or tasks—they transform Claude from a general-purpose agent into a specialized agent
+equipped with procedural knowledge that no model can fully possess.
+
+### What Skills Provide
+
+1. Specialized workflows - Multi-step procedures for specific domains
+2. Tool integrations - Instructions for working with specific file formats or APIs
+3. Domain expertise - Company-specific knowledge, schemas, business logic
+4. Bundled resources - Scripts, references, and assets for complex and repetitive tasks
+
+## Core Principles
+
+### Concise is Key
+
+The context window is a public good. Skills share the context window with everything else Claude needs: system prompt, conversation history, other Skills' metadata, and the actual user request.
+
+**Default assumption: Claude is already very smart.** Only add context Claude doesn't already have. Challenge each piece of information: "Does Claude really need this explanation?" and "Does this paragraph justify its token cost?"
+
+Prefer concise examples over verbose explanations.
+
+### Set Appropriate Degrees of Freedom
+
+Match the level of specificity to the task's fragility and variability:
+
+**High freedom (text-based instructions)**: Use when multiple approaches are valid, decisions depend on context, or heuristics guide the approach.
+
+**Medium freedom (pseudocode or scripts with parameters)**: Use when a preferred pattern exists, some variation is acceptable, or configuration affects behavior.
+
+**Low freedom (specific scripts, few parameters)**: Use when operations are fragile and error-prone, consistency is critical, or a specific sequence must be followed.
+
+Think of Claude as exploring a path: a narrow bridge with cliffs needs specific guardrails (low freedom), while an open field allows many routes (high freedom).
+
+### Anatomy of a Skill
+
+Every skill consists of a required SKILL.md file and optional bundled resources:
+
+```
+skill-name/
+├── SKILL.md (required)
+│   ├── YAML frontmatter metadata (required)
+│   │   ├── name: (required)
+│   │   └── description: (required)
+│   └── Markdown instructions (required)
+└── Bundled Resources (optional)
+    ├── scripts/          - Executable code (Python/Bash/etc.)
+    ├── references/       - Documentation intended to be loaded into context as needed
+    └── assets/           - Files used in output (templates, icons, fonts, etc.)
+```
+
+#### SKILL.md (required)
+
+Every SKILL.md consists of:
+
+- **Frontmatter** (YAML): Contains `name` and `description` fields. These are the only fields that Claude reads to determine when the skill gets used, thus it is very important to be clear and comprehensive in describing what the skill is, and when it should be used.
+- **Body** (Markdown): Instructions and guidance for using the skill. Only loaded AFTER the skill triggers (if at all).
+
+#### Bundled Resources (optional)
+
+##### Scripts (`scripts/`)
+
+Executable code (Python/Bash/etc.) for tasks that require deterministic reliability or are repeatedly rewritten.
+
+- **When to include**: When the same code is being rewritten repeatedly or deterministic reliability is needed
+- **Example**: `scripts/rotate_pdf.py` for PDF rotation tasks
+- **Benefits**: Token efficient, deterministic, may be executed without loading into context
+- **Note**: Scripts may still need to be read by Claude for patching or environment-specific adjustments
+
+##### References (`references/`)
+
+Documentation and reference material intended to be loaded as needed into context to inform Claude's process and thinking.
+
+- **When to include**: For documentation that Claude should reference while working
+- **Examples**: `references/finance.md` for financial schemas, `references/mnda.md` for company NDA template, `references/policies.md` for company policies, `references/api_docs.md` for API specifications
+- **Use cases**: Database schemas, API documentation, domain knowledge, company policies, detailed workflow guides
+- **Benefits**: Keeps SKILL.md lean, loaded only when Claude determines it's needed
+- **Best practice**: If files are large (>10k words), include grep search patterns in SKILL.md
+- **Avoid duplication**: Information should live in either SKILL.md or references files, not both. Prefer references files for detailed information unless it's truly core to the skill—this keeps SKILL.md lean while making information discoverable without hogging the context window. Keep only essential procedural instructions and workflow guidance in SKILL.md; move detailed reference material, schemas, and examples to references files.
+
+##### Assets (`assets/`)
+
+Files not intended to be loaded into context, but rather used within the output Claude produces.
+
+- **When to include**: When the skill needs files that will be used in the final output
+- **Examples**: `assets/logo.png` for brand assets, `assets/slides.pptx` for PowerPoint templates, `assets/frontend-template/` for HTML/React boilerplate, `assets/font.ttf` for typography
+- **Use cases**: Templates, images, icons, boilerplate code, fonts, sample documents that get copied or modified
+- **Benefits**: Separates output resources from documentation, enables Claude to use files without loading them into context
+
+#### What to Not Include in a Skill
+
+A skill should only contain essential files that directly support its functionality. Do NOT create extraneous documentation or auxiliary files, including:
+
+- README.md
+- INSTALLATION_GUIDE.md
+- QUICK_REFERENCE.md
+- CHANGELOG.md
+- etc.
+
+The skill should only contain the information needed for an AI agent to do the job at hand. It should not contain auxilary context about the process that went into creating it, setup and testing procedures, user-facing documentation, etc. Creating additional documentation files just adds clutter and confusion.
+
+### Progressive Disclosure Design Principle
+
+Skills use a three-level loading system to manage context efficiently:
+
+1. **Metadata (name + description)** - Always in context (~100 words)
+2. **SKILL.md body** - When skill triggers (<5k words)
+3. **Bundled resources** - As needed by Claude (Unlimited because scripts can be executed without reading into context window)
+
+#### Progressive Disclosure Patterns
+
+Keep SKILL.md body to the essentials and under 500 lines to minimize context bloat. Split content into separate files when approaching this limit. When splitting out content into other files, it is very important to reference them from SKILL.md and describe clearly when to read them, to ensure the reader of the skill knows they exist and when to use them.
+
+**Key principle:** When a skill supports multiple variations, frameworks, or options, keep only the core workflow and selection guidance in SKILL.md. Move variant-specific details (patterns, examples, configuration) into separate reference files.
+
+**Pattern 1: High-level guide with references**
+
+```markdown
+# PDF Processing
+
+## Quick start
+
+Extract text with pdfplumber:
+[code example]
+
+## Advanced features
+
+- **Form filling**: See [FORMS.md](FORMS.md) for complete guide
+- **API reference**: See [REFERENCE.md](REFERENCE.md) for all methods
+- **Examples**: See [EXAMPLES.md](EXAMPLES.md) for common patterns
+```
+
+Claude loads FORMS.md, REFERENCE.md, or EXAMPLES.md only when needed.
+
+**Pattern 2: Domain-specific organization**
+
+For Skills with multiple domains, organize content by domain to avoid loading irrelevant context:
+
+```
+bigquery-skill/
+├── SKILL.md (overview and navigation)
+└── reference/
+    ├── finance.md (revenue, billing metrics)
+    ├── sales.md (opportunities, pipeline)
+    ├── product.md (API usage, features)
+    └── marketing.md (campaigns, attribution)
+```
+
+When a user asks about sales metrics, Claude only reads sales.md.
+
+Similarly, for skills supporting multiple frameworks or variants, organize by variant:
+
+```
+cloud-deploy/
+├── SKILL.md (workflow + provider selection)
+└── references/
+    ├── aws.md (AWS deployment patterns)
+    ├── gcp.md (GCP deployment patterns)
+    └── azure.md (Azure deployment patterns)
+```
+
+When the user chooses AWS, Claude only reads aws.md.
+
+**Pattern 3: Conditional details**
+
+Show basic content, link to advanced content:
+
+```markdown
+# DOCX Processing
+
+## Creating documents
+
+Use docx-js for new documents. See [DOCX-JS.md](DOCX-JS.md).
+
+## Editing documents
+
+For simple edits, modify the XML directly.
+
+**For tracked changes**: See [REDLINING.md](REDLINING.md)
+**For OOXML details**: See [OOXML.md](OOXML.md)
+```
+
+Claude reads REDLINING.md or OOXML.md only when the user needs those features.
+
+**Important guidelines:**
+
+- **Avoid deeply nested references** - Keep references one level deep from SKILL.md. All reference files should link directly from SKILL.md.
+- **Structure longer reference files** - For files longer than 100 lines, include a table of contents at the top so Claude can see the full scope when previewing.
+
+## Skill Creation Process
+
+Skill creation involves these steps:
+
+1. Understand the skill with concrete examples
+2. Plan reusable skill contents (scripts, references, assets)
+3. Initialize the skill (run init_skill.py)
+4. Edit the skill (implement resources and write SKILL.md)
+5. Package the skill (run package_skill.py)
+6. Iterate based on real usage
+
+Follow these steps in order, skipping only if there is a clear reason why they are not applicable.
+
+### Step 1: Understanding the Skill with Concrete Examples
+
+Skip this step only when the skill's usage patterns are already clearly understood. It remains valuable even when working with an existing skill.
+
+To create an effective skill, clearly understand concrete examples of how the skill will be used. This understanding can come from either direct user examples or generated examples that are validated with user feedback.
+
+For example, when building an image-editor skill, relevant questions include:
+
+- "What functionality should the image-editor skill support? Editing, rotating, anything else?"
+- "Can you give some examples of how this skill would be used?"
+- "I can imagine users asking for things like 'Remove the red-eye from this image' or 'Rotate this image'. Are there other ways you imagine this skill being used?"
+- "What would a user say that should trigger this skill?"
+
+To avoid overwhelming users, avoid asking too many questions in a single message. Start with the most important questions and follow up as needed for better effectiveness.
+
+Conclude this step when there is a clear sense of the functionality the skill should support.
+
+### Step 2: Planning the Reusable Skill Contents
+
+To turn concrete examples into an effective skill, analyze each example by:
+
+1. Considering how to execute on the example from scratch
+2. Identifying what scripts, references, and assets would be helpful when executing these workflows repeatedly
+
+Example: When building a `pdf-editor` skill to handle queries like "Help me rotate this PDF," the analysis shows:
+
+1. Rotating a PDF requires re-writing the same code each time
+2. A `scripts/rotate_pdf.py` script would be helpful to store in the skill
+
+Example: When designing a `frontend-webapp-builder` skill for queries like "Build me a todo app" or "Build me a dashboard to track my steps," the analysis shows:
+
+1. Writing a frontend webapp requires the same boilerplate HTML/React each time
+2. An `assets/hello-world/` template containing the boilerplate HTML/React project files would be helpful to store in the skill
+
+Example: When building a `big-query` skill to handle queries like "How many users have logged in today?" the analysis shows:
+
+1. Querying BigQuery requires re-discovering the table schemas and relationships each time
+2. A `references/schema.md` file documenting the table schemas would be helpful to store in the skill
+
+To establish the skill's contents, analyze each concrete example to create a list of the reusable resources to include: scripts, references, and assets.
+
+### Step 3: Initializing the Skill
+
+At this point, it is time to actually create the skill.
+
+Skip this step only if the skill being developed already exists, and iteration or packaging is needed. In this case, continue to the next step.
+
+When creating a new skill from scratch, always run the `init_skill.py` script. The script conveniently generates a new template skill directory that automatically includes everything a skill requires, making the skill creation process much more efficient and reliable.
+
+Usage:
+
+```bash
+scripts/init_skill.py <skill-name> --path <output-directory>
+```
+
+The script:
+
+- Creates the skill directory at the specified path
+- Generates a SKILL.md template with proper frontmatter and TODO placeholders
+- Creates example resource directories: `scripts/`, `references/`, and `assets/`
+- Adds example files in each directory that can be customized or deleted
+
+After initialization, customize or remove the generated SKILL.md and example files as needed.
+
+### Step 4: Edit the Skill
+
+When editing the (newly-generated or existing) skill, remember that the skill is being created for another instance of Claude to use. Include information that would be beneficial and non-obvious to Claude. Consider what procedural knowledge, domain-specific details, or reusable assets would help another Claude instance execute these tasks more effectively.
+
+#### Learn Proven Design Patterns
+
+Consult these helpful guides based on your skill's needs:
+
+- **Multi-step processes**: See references/workflows.md for sequential workflows and conditional logic
+- **Specific output formats or quality standards**: See references/output-patterns.md for template and example patterns
+
+These files contain established best practices for effective skill design.
+
+#### Start with Reusable Skill Contents
+
+To begin implementation, start with the reusable resources identified above: `scripts/`, `references/`, and `assets/` files. Note that this step may require user input. For example, when implementing a `brand-guidelines` skill, the user may need to provide brand assets or templates to store in `assets/`, or documentation to store in `references/`.
+
+Added scripts must be tested by actually running them to ensure there are no bugs and that the output matches what is expected. If there are many similar scripts, only a representative sample needs to be tested to ensure confidence that they all work while balancing time to completion.
+
+Any example files and directories not needed for the skill should be deleted. The initialization script creates example files in `scripts/`, `references/`, and `assets/` to demonstrate structure, but most skills won't need all of them.
+
+#### Update SKILL.md
+
+**Writing Guidelines:** Always use imperative/infinitive form.
+
+##### Frontmatter
+
+Write the YAML frontmatter with `name` and `description`:
+
+- `name`: The skill name
+- `description`: This is the primary triggering mechanism for your skill, and helps Claude understand when to use the skill.
+  - Include both what the Skill does and specific triggers/contexts for when to use it.
+  - Include all "when to use" information here - Not in the body. The body is only loaded after triggering, so "When to Use This Skill" sections in the body are not helpful to Claude.
+  - Example description for a `docx` skill: "Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. Use when Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks"
+
+Do not include any other fields in YAML frontmatter.
+
+##### Body
+
+Write instructions for using the skill and its bundled resources.
+
+### Step 5: Packaging a Skill
+
+Once development of the skill is complete, it must be packaged into a distributable .skill file that gets shared with the user. The packaging process automatically validates the skill first to ensure it meets all requirements:
+
+```bash
+scripts/package_skill.py <path/to/skill-folder>
+```
+
+Optional output directory specification:
+
+```bash
+scripts/package_skill.py <path/to/skill-folder> ./dist
+```
+
+The packaging script will:
+
+1. **Validate** the skill automatically, checking:
+
+   - YAML frontmatter format and required fields
+   - Skill naming conventions and directory structure
+   - Description completeness and quality
+   - File organization and resource references
+
+2. **Package** the skill if validation passes, creating a .skill file named after the skill (e.g., `my-skill.skill`) that includes all files and maintains the proper directory structure for distribution. The .skill file is a zip file with a .skill extension.
+
+If validation fails, the script will report the errors and exit without creating a package. Fix any validation errors and run the packaging command again.
+
+### Step 6: Iterate
+
+After testing the skill, users may request improvements. Often this happens right after using the skill, with fresh context of how the skill performed.
+
+**Iteration workflow:**
+
+1. Use the skill on real tasks
+2. Notice struggles or inefficiencies
+3. Identify how SKILL.md or bundled resources should be updated
+4. Implement changes and test again

adapters-output/codebuddy/skill-creator/workflows/skill-creator.json

@@ -0,0 +1,171 @@
+{
+  "id": "skill-creator",
+  "name": "Skill Creator",
+  "description": "Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "Specialized workflows - Multi-step procedures for specific domains",
+      "description": "Specialized workflows - Multi-step procedures for specific domains",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "Tool integrations - Instructions for working with specific file formats or APIs",
+      "description": "Tool integrations - Instructions for working with specific file formats or APIs",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "Domain expertise - Company-specific knowledge, schemas, business logic",
+      "description": "Domain expertise - Company-specific knowledge, schemas, business logic",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "Bundled resources - Scripts, references, and assets for complex and repetitive tasks",
+      "description": "Bundled resources - Scripts, references, and assets for complex and repetitive tasks",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**Metadata (name + description)** - Always in context (~100 words)",
+      "description": "**Metadata (name + description)** - Always in context (~100 words)",
+      "type": "instruction"
+    },
+    {
+      "id": 6,
+      "name": "**SKILL.md body** - When skill triggers (<5k words)",
+      "description": "**SKILL.md body** - When skill triggers (<5k words)",
+      "type": "instruction"
+    },
+    {
+      "id": 7,
+      "name": "**Bundled resources** - As needed by Claude (Unlimited because scripts can be executed without reading into context window)",
+      "description": "**Bundled resources** - As needed by Claude (Unlimited because scripts can be executed without reading into context window)",
+      "type": "instruction"
+    },
+    {
+      "id": 8,
+      "name": "Understand the skill with concrete examples",
+      "description": "Understand the skill with concrete examples",
+      "type": "instruction"
+    },
+    {
+      "id": 9,
+      "name": "Plan reusable skill contents (scripts, references, assets)",
+      "description": "Plan reusable skill contents (scripts, references, assets)",
+      "type": "instruction"
+    },
+    {
+      "id": 10,
+      "name": "Initialize the skill (run init_skill.py)",
+      "description": "Initialize the skill (run init_skill.py)",
+      "type": "instruction"
+    },
+    {
+      "id": 11,
+      "name": "Edit the skill (implement resources and write SKILL.md)",
+      "description": "Edit the skill (implement resources and write SKILL.md)",
+      "type": "instruction"
+    },
+    {
+      "id": 12,
+      "name": "Package the skill (run package_skill.py)",
+      "description": "Package the skill (run package_skill.py)",
+      "type": "instruction"
+    },
+    {
+      "id": 13,
+      "name": "Iterate based on real usage",
+      "description": "Iterate based on real usage",
+      "type": "instruction"
+    },
+    {
+      "id": 14,
+      "name": "Considering how to execute on the example from scratch",
+      "description": "Considering how to execute on the example from scratch",
+      "type": "instruction"
+    },
+    {
+      "id": 15,
+      "name": "Identifying what scripts, references, and assets would be helpful when executing these workflows repeatedly",
+      "description": "Identifying what scripts, references, and assets would be helpful when executing these workflows repeatedly",
+      "type": "instruction"
+    },
+    {
+      "id": 16,
+      "name": "Rotating a PDF requires re-writing the same code each time",
+      "description": "Rotating a PDF requires re-writing the same code each time",
+      "type": "instruction"
+    },
+    {
+      "id": 17,
+      "name": "A `scripts/rotate_pdf.py` script would be helpful to store in the skill",
+      "description": "A `scripts/rotate_pdf.py` script would be helpful to store in the skill",
+      "type": "instruction"
+    },
+    {
+      "id": 18,
+      "name": "Writing a frontend webapp requires the same boilerplate HTML/React each time",
+      "description": "Writing a frontend webapp requires the same boilerplate HTML/React each time",
+      "type": "instruction"
+    },
+    {
+      "id": 19,
+      "name": "An `assets/hello-world/` template containing the boilerplate HTML/React project files would be helpful to store in the skill",
+      "description": "An `assets/hello-world/` template containing the boilerplate HTML/React project files would be helpful to store in the skill",
+      "type": "instruction"
+    },
+    {
+      "id": 20,
+      "name": "Querying BigQuery requires re-discovering the table schemas and relationships each time",
+      "description": "Querying BigQuery requires re-discovering the table schemas and relationships each time",
+      "type": "instruction"
+    },
+    {
+      "id": 21,
+      "name": "A `references/schema.md` file documenting the table schemas would be helpful to store in the skill",
+      "description": "A `references/schema.md` file documenting the table schemas would be helpful to store in the skill",
+      "type": "instruction"
+    },
+    {
+      "id": 22,
+      "name": "**Validate** the skill automatically, checking",
+      "description": "**Validate** the skill automatically, checking:",
+      "type": "instruction"
+    },
+    {
+      "id": 23,
+      "name": "**Package** the skill if validation passes, creating a .skill file named after the skill (e.g., `my-skill.skill`) that includes all files and maintains the proper directory structure for distribution. The .skill file is a zip file with a .skill extension.",
+      "description": "**Package** the skill if validation passes, creating a .skill file named after the skill (e.g., `my-skill.skill`) that includes all files and maintains the proper directory structure for distribution. The .skill file is a zip file with a .skill extension.",
+      "type": "instruction"
+    },
+    {
+      "id": 24,
+      "name": "Use the skill on real tasks",
+      "description": "Use the skill on real tasks",
+      "type": "instruction"
+    },
+    {
+      "id": 25,
+      "name": "Notice struggles or inefficiencies",
+      "description": "Notice struggles or inefficiencies",
+      "type": "instruction"
+    },
+    {
+      "id": 26,
+      "name": "Identify how SKILL.md or bundled resources should be updated",
+      "description": "Identify how SKILL.md or bundled resources should be updated",
+      "type": "instruction"
+    },
+    {
+      "id": 27,
+      "name": "Implement changes and test again",
+      "description": "Implement changes and test again",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/slack-gif-creator/manifest.json

@@ -0,0 +1,48 @@
+{
+  "name": "slack-gif-creator",
+  "version": "1.0.0",
+  "description": "Knowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like \"make me a GIF of X doing Y for Slack.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "slack-gif-creator",
+      "name": "Slack GIF Creator",
+      "description": "Knowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like \"make me a GIF of X doing Y for Slack.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**Fewer frames** - Lower FPS (10 instead of 20) or shorter duration",
+          "description": "**Fewer frames** - Lower FPS (10 instead of 20) or shorter duration",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**Fewer colors** - `num_colors=48` instead of 128",
+          "description": "**Fewer colors** - `num_colors=48` instead of 128",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**Smaller dimensions** - 128x128 instead of 480x480",
+          "description": "**Smaller dimensions** - 128x128 instead of 480x480",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**Remove duplicates** - `remove_duplicates=True` in save()",
+          "description": "**Remove duplicates** - `remove_duplicates=True` in save()",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**Emoji mode** - `optimize_for_emoji=True` auto-optimizes",
+          "description": "**Emoji mode** - `optimize_for_emoji=True` auto-optimizes",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/slack-gif-creator/skills/slack-gif-creator/SKILL.md

@@ -0,0 +1,254 @@
+---
+name: slack-gif-creator
+description: Knowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."
+license: Complete terms in LICENSE.txt
+---
+
+# Slack GIF Creator
+
+A toolkit providing utilities and knowledge for creating animated GIFs optimized for Slack.
+
+## Slack Requirements
+
+**Dimensions:**
+- Emoji GIFs: 128x128 (recommended)
+- Message GIFs: 480x480
+
+**Parameters:**
+- FPS: 10-30 (lower is smaller file size)
+- Colors: 48-128 (fewer = smaller file size)
+- Duration: Keep under 3 seconds for emoji GIFs
+
+## Core Workflow
+
+```python
+from core.gif_builder import GIFBuilder
+from PIL import Image, ImageDraw
+
+# 1. Create builder
+builder = GIFBuilder(width=128, height=128, fps=10)
+
+# 2. Generate frames
+for i in range(12):
+    frame = Image.new('RGB', (128, 128), (240, 248, 255))
+    draw = ImageDraw.Draw(frame)
+
+    # Draw your animation using PIL primitives
+    # (circles, polygons, lines, etc.)
+
+    builder.add_frame(frame)
+
+# 3. Save with optimization
+builder.save('output.gif', num_colors=48, optimize_for_emoji=True)
+```
+
+## Drawing Graphics
+
+### Working with User-Uploaded Images
+If a user uploads an image, consider whether they want to:
+- **Use it directly** (e.g., "animate this", "split this into frames")
+- **Use it as inspiration** (e.g., "make something like this")
+
+Load and work with images using PIL:
+```python
+from PIL import Image
+
+uploaded = Image.open('file.png')
+# Use directly, or just as reference for colors/style
+```
+
+### Drawing from Scratch
+When drawing graphics from scratch, use PIL ImageDraw primitives:
+
+```python
+from PIL import ImageDraw
+
+draw = ImageDraw.Draw(frame)
+
+# Circles/ovals
+draw.ellipse([x1, y1, x2, y2], fill=(r, g, b), outline=(r, g, b), width=3)
+
+# Stars, triangles, any polygon
+points = [(x1, y1), (x2, y2), (x3, y3), ...]
+draw.polygon(points, fill=(r, g, b), outline=(r, g, b), width=3)
+
+# Lines
+draw.line([(x1, y1), (x2, y2)], fill=(r, g, b), width=5)
+
+# Rectangles
+draw.rectangle([x1, y1, x2, y2], fill=(r, g, b), outline=(r, g, b), width=3)
+```
+
+**Don't use:** Emoji fonts (unreliable across platforms) or assume pre-packaged graphics exist in this skill.
+
+### Making Graphics Look Good
+
+Graphics should look polished and creative, not basic. Here's how:
+
+**Use thicker lines** - Always set `width=2` or higher for outlines and lines. Thin lines (width=1) look choppy and amateurish.
+
+**Add visual depth**:
+- Use gradients for backgrounds (`create_gradient_background`)
+- Layer multiple shapes for complexity (e.g., a star with a smaller star inside)
+
+**Make shapes more interesting**:
+- Don't just draw a plain circle - add highlights, rings, or patterns
+- Stars can have glows (draw larger, semi-transparent versions behind)
+- Combine multiple shapes (stars + sparkles, circles + rings)
+
+**Pay attention to colors**:
+- Use vibrant, complementary colors
+- Add contrast (dark outlines on light shapes, light outlines on dark shapes)
+- Consider the overall composition
+
+**For complex shapes** (hearts, snowflakes, etc.):
+- Use combinations of polygons and ellipses
+- Calculate points carefully for symmetry
+- Add details (a heart can have a highlight curve, snowflakes have intricate branches)
+
+Be creative and detailed! A good Slack GIF should look polished, not like placeholder graphics.
+
+## Available Utilities
+
+### GIFBuilder (`core.gif_builder`)
+Assembles frames and optimizes for Slack:
+```python
+builder = GIFBuilder(width=128, height=128, fps=10)
+builder.add_frame(frame)  # Add PIL Image
+builder.add_frames(frames)  # Add list of frames
+builder.save('out.gif', num_colors=48, optimize_for_emoji=True, remove_duplicates=True)
+```
+
+### Validators (`core.validators`)
+Check if GIF meets Slack requirements:
+```python
+from core.validators import validate_gif, is_slack_ready
+
+# Detailed validation
+passes, info = validate_gif('my.gif', is_emoji=True, verbose=True)
+
+# Quick check
+if is_slack_ready('my.gif'):
+    print("Ready!")
+```
+
+### Easing Functions (`core.easing`)
+Smooth motion instead of linear:
+```python
+from core.easing import interpolate
+
+# Progress from 0.0 to 1.0
+t = i / (num_frames - 1)
+
+# Apply easing
+y = interpolate(start=0, end=400, t=t, easing='ease_out')
+
+# Available: linear, ease_in, ease_out, ease_in_out,
+#           bounce_out, elastic_out, back_out
+```
+
+### Frame Helpers (`core.frame_composer`)
+Convenience functions for common needs:
+```python
+from core.frame_composer import (
+    create_blank_frame,         # Solid color background
+    create_gradient_background,  # Vertical gradient
+    draw_circle,                # Helper for circles
+    draw_text,                  # Simple text rendering
+    draw_star                   # 5-pointed star
+)
+```
+
+## Animation Concepts
+
+### Shake/Vibrate
+Offset object position with oscillation:
+- Use `math.sin()` or `math.cos()` with frame index
+- Add small random variations for natural feel
+- Apply to x and/or y position
+
+### Pulse/Heartbeat
+Scale object size rhythmically:
+- Use `math.sin(t * frequency * 2 * math.pi)` for smooth pulse
+- For heartbeat: two quick pulses then pause (adjust sine wave)
+- Scale between 0.8 and 1.2 of base size
+
+### Bounce
+Object falls and bounces:
+- Use `interpolate()` with `easing='bounce_out'` for landing
+- Use `easing='ease_in'` for falling (accelerating)
+- Apply gravity by increasing y velocity each frame
+
+### Spin/Rotate
+Rotate object around center:
+- PIL: `image.rotate(angle, resample=Image.BICUBIC)`
+- For wobble: use sine wave for angle instead of linear
+
+### Fade In/Out
+Gradually appear or disappear:
+- Create RGBA image, adjust alpha channel
+- Or use `Image.blend(image1, image2, alpha)`
+- Fade in: alpha from 0 to 1
+- Fade out: alpha from 1 to 0
+
+### Slide
+Move object from off-screen to position:
+- Start position: outside frame bounds
+- End position: target location
+- Use `interpolate()` with `easing='ease_out'` for smooth stop
+- For overshoot: use `easing='back_out'`
+
+### Zoom
+Scale and position for zoom effect:
+- Zoom in: scale from 0.1 to 2.0, crop center
+- Zoom out: scale from 2.0 to 1.0
+- Can add motion blur for drama (PIL filter)
+
+### Explode/Particle Burst
+Create particles radiating outward:
+- Generate particles with random angles and velocities
+- Update each particle: `x += vx`, `y += vy`
+- Add gravity: `vy += gravity_constant`
+- Fade out particles over time (reduce alpha)
+
+## Optimization Strategies
+
+Only when asked to make the file size smaller, implement a few of the following methods:
+
+1. **Fewer frames** - Lower FPS (10 instead of 20) or shorter duration
+2. **Fewer colors** - `num_colors=48` instead of 128
+3. **Smaller dimensions** - 128x128 instead of 480x480
+4. **Remove duplicates** - `remove_duplicates=True` in save()
+5. **Emoji mode** - `optimize_for_emoji=True` auto-optimizes
+
+```python
+# Maximum optimization for emoji
+builder.save(
+    'emoji.gif',
+    num_colors=48,
+    optimize_for_emoji=True,
+    remove_duplicates=True
+)
+```
+
+## Philosophy
+
+This skill provides:
+- **Knowledge**: Slack's requirements and animation concepts
+- **Utilities**: GIFBuilder, validators, easing functions
+- **Flexibility**: Create the animation logic using PIL primitives
+
+It does NOT provide:
+- Rigid animation templates or pre-made functions
+- Emoji font rendering (unreliable across platforms)
+- A library of pre-packaged graphics built into the skill
+
+**Note on user uploads**: This skill doesn't include pre-built graphics, but if a user uploads an image, use PIL to load and work with it - interpret based on their request whether they want it used directly or just as inspiration.
+
+Be creative! Combine concepts (bouncing + rotating, pulsing + sliding, etc.) and use PIL's full capabilities.
+
+## Dependencies
+
+```bash
+pip install pillow imageio numpy
+```

adapters-output/codebuddy/slack-gif-creator/workflows/slack-gif-creator.json

@@ -0,0 +1,39 @@
+{
+  "id": "slack-gif-creator",
+  "name": "Slack GIF Creator",
+  "description": "Knowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like \"make me a GIF of X doing Y for Slack.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**Fewer frames** - Lower FPS (10 instead of 20) or shorter duration",
+      "description": "**Fewer frames** - Lower FPS (10 instead of 20) or shorter duration",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**Fewer colors** - `num_colors=48` instead of 128",
+      "description": "**Fewer colors** - `num_colors=48` instead of 128",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**Smaller dimensions** - 128x128 instead of 480x480",
+      "description": "**Smaller dimensions** - 128x128 instead of 480x480",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**Remove duplicates** - `remove_duplicates=True` in save()",
+      "description": "**Remove duplicates** - `remove_duplicates=True` in save()",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**Emoji mode** - `optimize_for_emoji=True` auto-optimizes",
+      "description": "**Emoji mode** - `optimize_for_emoji=True` auto-optimizes",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/teaching-resource-generator/manifest.json

@@ -0,0 +1,48 @@
+{
+  "name": "teaching-resource-generator",
+  "version": "1.0.0",
+  "description": "帮助生成各种教学资源，包括课件、练习题、教学案例、学习指南等。适用于快速创建高质量的教学材料。",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "teaching-resource-generator",
+      "name": "教学资源生成技能",
+      "description": "帮助生成各种教学资源，包括课件、练习题、教学案例、学习指南等。适用于快速创建高质量的教学材料。",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**内容规划**",
+          "description": "**内容规划**: 确定课件主题和结构",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**内容生成**",
+          "description": "**内容生成**: 创建每张幻灯片的内容",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**视觉设计**",
+          "description": "**视觉设计**: 添加图表、图片和视觉元素",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**互动设计**",
+          "description": "**互动设计**: 设计互动环节和讨论问题",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**优化完善**",
+          "description": "**优化完善**: 检查逻辑和视觉效果",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/teaching-resource-generator/skills/teaching-resource-generator/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: teaching-resource-generator
+description: 帮助生成各种教学资源，包括课件、练习题、教学案例、学习指南等。适用于快速创建高质量的教学材料。
+---
+
+# 教学资源生成技能
+
+## 概述
+
+本技能帮助您快速生成各种教学资源，包括课件、练习题、教学案例、学习指南等。
+
+**关键词**: 教学资源、课件制作、练习题、教学案例、学习指南、教学材料
+
+## 核心功能
+
+### 1. 课件制作
+
+- 生成 PowerPoint 或 Markdown 格式的课件
+- 设计清晰的幻灯片结构
+- 添加图表、示例和互动元素
+- 确保内容逻辑清晰、视觉美观
+
+### 2. 练习题生成
+
+- 生成各种类型的练习题
+- 设计不同难度级别的题目
+- 创建配套的答案和解析
+- 生成练习题集和测试卷
+
+### 3. 教学案例编写
+
+- 编写真实或模拟的教学案例
+- 设计案例讨论问题
+- 提供案例分析和解决方案
+- 创建案例库和案例集
+
+### 4. 学习指南创建
+
+- 编写学习指南和复习材料
+- 创建知识要点总结
+- 设计学习路径和计划
+- 生成学习检查清单
+
+## 使用指南
+
+### 课件制作流程
+
+1. **内容规划**: 确定课件主题和结构
+2. **内容生成**: 创建每张幻灯片的内容
+3. **视觉设计**: 添加图表、图片和视觉元素
+4. **互动设计**: 设计互动环节和讨论问题
+5. **优化完善**: 检查逻辑和视觉效果
+
+### 练习题生成原则
+
+- **多样性**: 使用多种题型
+- **层次性**: 覆盖不同难度级别
+- **针对性**: 针对具体知识点
+- **实用性**: 贴近实际应用场景
+
+### 教学案例要求
+
+- **真实性**: 基于真实或合理的场景
+- **典型性**: 具有代表性
+- **启发性**: 能引发思考和讨论
+- **完整性**: 包含背景、问题、分析、解决方案
+
+## 输出格式
+
+教学资源应包含：
+
+- **资源类型**: 明确资源类型（课件、练习题等）
+- **目标受众**: 适用对象和水平
+- **内容结构**: 清晰的目录和结构
+- **使用说明**: 如何使用该资源
+- **配套材料**: 相关的补充材料
+
+## 最佳实践
+
+- 确保内容准确、专业
+- 保持格式统一、美观
+- 注重实用性和可操作性
+- 考虑不同学习者的需求
+- 提供清晰的使用指导
+- 定期更新和完善资源

adapters-output/codebuddy/teaching-resource-generator/workflows/teaching-resource-generator.json

@@ -0,0 +1,39 @@
+{
+  "id": "teaching-resource-generator",
+  "name": "教学资源生成技能",
+  "description": "帮助生成各种教学资源，包括课件、练习题、教学案例、学习指南等。适用于快速创建高质量的教学材料。",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**内容规划**",
+      "description": "**内容规划**: 确定课件主题和结构",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**内容生成**",
+      "description": "**内容生成**: 创建每张幻灯片的内容",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**视觉设计**",
+      "description": "**视觉设计**: 添加图表、图片和视觉元素",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**互动设计**",
+      "description": "**互动设计**: 设计互动环节和讨论问题",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**优化完善**",
+      "description": "**优化完善**: 检查逻辑和视觉效果",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/test-writer/manifest.json

@@ -0,0 +1,48 @@
+{
+  "name": "test-writer",
+  "version": "1.0.0",
+  "description": "帮助编写单元测试、集成测试和端到端测试。支持多种测试框架，生成测试用例、测试数据和测试报告。适用于确保代码质量和功能正确性。",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "test-writer",
+      "name": "测试编写技能",
+      "description": "帮助编写单元测试、集成测试和端到端测试。支持多种测试框架，生成测试用例、测试数据和测试报告。适用于确保代码质量和功能正确性。",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**全面性**",
+          "description": "**全面性**: 覆盖正常流程、边界情况和异常情况",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**独立性**",
+          "description": "**独立性**: 每个测试应独立运行，不依赖其他测试",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**可重复性**",
+          "description": "**可重复性**: 测试结果应一致，不受环境影响",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**清晰性**",
+          "description": "**清晰性**: 测试代码应清晰易懂",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**快速性**",
+          "description": "**快速性**: 测试应快速执行",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/test-writer/skills/test-writer/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: test-writer
+description: 帮助编写单元测试、集成测试和端到端测试。支持多种测试框架，生成测试用例、测试数据和测试报告。适用于确保代码质量和功能正确性。
+---
+
+# 测试编写技能
+
+## 概述
+
+本技能帮助您编写各种类型的测试，包括单元测试、集成测试和端到端测试。
+
+**关键词**: 测试编写、单元测试、集成测试、端到端测试、测试用例、测试框架
+
+## 核心功能
+
+### 1. 单元测试编写
+
+- 为函数和类编写单元测试
+- 设计测试用例覆盖各种场景
+- 使用 Mock 和 Stub 隔离依赖
+- 确保测试的独立性和可重复性
+
+### 2. 集成测试设计
+
+- 编写模块间的集成测试
+- 测试 API 接口和数据库交互
+- 验证系统组件的协作
+- 设计测试数据和测试环境
+
+### 3. 端到端测试
+
+- 编写完整的用户流程测试
+- 测试关键业务场景
+- 验证系统端到端的功能
+- 使用自动化测试工具
+
+### 4. 测试工具和框架
+
+- 支持主流测试框架（JUnit, pytest, Jest 等）
+- 生成测试报告和覆盖率报告
+- 创建测试配置和测试环境
+- 设计测试数据和 Fixture
+
+## 使用指南
+
+### 测试编写原则
+
+1. **全面性**: 覆盖正常流程、边界情况和异常情况
+2. **独立性**: 每个测试应独立运行，不依赖其他测试
+3. **可重复性**: 测试结果应一致，不受环境影响
+4. **清晰性**: 测试代码应清晰易懂
+5. **快速性**: 测试应快速执行
+
+### 测试用例设计
+
+- **正常场景**: 测试正常的功能流程
+- **边界情况**: 测试边界值和极限情况
+- **异常情况**: 测试错误处理和异常情况
+- **性能测试**: 测试性能和负载（如需要）
+
+### 测试覆盖率
+
+- 目标覆盖率: 80% 以上（根据项目需求）
+- 关键路径: 100% 覆盖
+- 边界情况: 重点覆盖
+- 异常处理: 确保覆盖
+
+## 输出格式
+
+测试代码应包含：
+
+- **测试文件**: 完整的测试代码文件
+- **测试用例**: 清晰的测试用例和描述
+- **测试数据**: 测试数据和 Fixture
+- **测试配置**: 测试配置文件
+- **测试报告**: 测试执行结果和覆盖率
+
+## 最佳实践
+
+- 使用 AAA 模式（Arrange-Act-Assert）
+- 测试名称应描述测试内容
+- 一个测试只测试一个功能点
+- 使用 Mock 隔离外部依赖
+- 保持测试代码简洁
+- 定期运行测试，确保通过
+- 关注测试覆盖率，但不盲目追求 100%

adapters-output/codebuddy/test-writer/workflows/test-writer.json

@@ -0,0 +1,39 @@
+{
+  "id": "test-writer",
+  "name": "测试编写技能",
+  "description": "帮助编写单元测试、集成测试和端到端测试。支持多种测试框架，生成测试用例、测试数据和测试报告。适用于确保代码质量和功能正确性。",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**全面性**",
+      "description": "**全面性**: 覆盖正常流程、边界情况和异常情况",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**独立性**",
+      "description": "**独立性**: 每个测试应独立运行，不依赖其他测试",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**可重复性**",
+      "description": "**可重复性**: 测试结果应一致，不受环境影响",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**清晰性**",
+      "description": "**清晰性**: 测试代码应清晰易懂",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**快速性**",
+      "description": "**快速性**: 测试应快速执行",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/theme-factory/manifest.json

@@ -0,0 +1,126 @@
+{
+  "name": "theme-factory",
+  "version": "1.0.0",
+  "description": "Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "theme-factory",
+      "name": "Theme Factory Skill",
+      "description": "Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**Show the theme showcase**",
+          "description": "**Show the theme showcase**: Display the `theme-showcase.pdf` file to allow users to see all available themes visually. Do not make any modifications to it; simply show the file for viewing.",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**Ask for their choice**",
+          "description": "**Ask for their choice**: Ask which theme to apply to the deck",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**Wait for selection**",
+          "description": "**Wait for selection**: Get explicit confirmation about the chosen theme",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**Apply the theme**",
+          "description": "**Apply the theme**: Once a theme has been chosen, apply the selected theme's colors and fonts to the deck/artifact",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**Ocean Depths** - Professional and calming maritime theme",
+          "description": "**Ocean Depths** - Professional and calming maritime theme",
+          "type": "instruction"
+        },
+        {
+          "id": 6,
+          "name": "**Sunset Boulevard** - Warm and vibrant sunset colors",
+          "description": "**Sunset Boulevard** - Warm and vibrant sunset colors",
+          "type": "instruction"
+        },
+        {
+          "id": 7,
+          "name": "**Forest Canopy** - Natural and grounded earth tones",
+          "description": "**Forest Canopy** - Natural and grounded earth tones",
+          "type": "instruction"
+        },
+        {
+          "id": 8,
+          "name": "**Modern Minimalist** - Clean and contemporary grayscale",
+          "description": "**Modern Minimalist** - Clean and contemporary grayscale",
+          "type": "instruction"
+        },
+        {
+          "id": 9,
+          "name": "**Golden Hour** - Rich and warm autumnal palette",
+          "description": "**Golden Hour** - Rich and warm autumnal palette",
+          "type": "instruction"
+        },
+        {
+          "id": 10,
+          "name": "**Arctic Frost** - Cool and crisp winter-inspired theme",
+          "description": "**Arctic Frost** - Cool and crisp winter-inspired theme",
+          "type": "instruction"
+        },
+        {
+          "id": 11,
+          "name": "**Desert Rose** - Soft and sophisticated dusty tones",
+          "description": "**Desert Rose** - Soft and sophisticated dusty tones",
+          "type": "instruction"
+        },
+        {
+          "id": 12,
+          "name": "**Tech Innovation** - Bold and modern tech aesthetic",
+          "description": "**Tech Innovation** - Bold and modern tech aesthetic",
+          "type": "instruction"
+        },
+        {
+          "id": 13,
+          "name": "**Botanical Garden** - Fresh and organic garden colors",
+          "description": "**Botanical Garden** - Fresh and organic garden colors",
+          "type": "instruction"
+        },
+        {
+          "id": 14,
+          "name": "**Midnight Galaxy** - Dramatic and cosmic deep tones",
+          "description": "**Midnight Galaxy** - Dramatic and cosmic deep tones",
+          "type": "instruction"
+        },
+        {
+          "id": 15,
+          "name": "Read the corresponding theme file from the `themes/` directory",
+          "description": "Read the corresponding theme file from the `themes/` directory",
+          "type": "instruction"
+        },
+        {
+          "id": 16,
+          "name": "Apply the specified colors and fonts consistently throughout the deck",
+          "description": "Apply the specified colors and fonts consistently throughout the deck",
+          "type": "instruction"
+        },
+        {
+          "id": 17,
+          "name": "Ensure proper contrast and readability",
+          "description": "Ensure proper contrast and readability",
+          "type": "instruction"
+        },
+        {
+          "id": 18,
+          "name": "Maintain the theme's visual identity across all slides",
+          "description": "Maintain the theme's visual identity across all slides",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/theme-factory/skills/theme-factory/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: theme-factory
+description: Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.
+license: Complete terms in LICENSE.txt
+---
+
+
+# Theme Factory Skill
+
+This skill provides a curated collection of professional font and color themes themes, each with carefully selected color palettes and font pairings. Once a theme is chosen, it can be applied to any artifact.
+
+## Purpose
+
+To apply consistent, professional styling to presentation slide decks, use this skill. Each theme includes:
+- A cohesive color palette with hex codes
+- Complementary font pairings for headers and body text
+- A distinct visual identity suitable for different contexts and audiences
+
+## Usage Instructions
+
+To apply styling to a slide deck or other artifact:
+
+1. **Show the theme showcase**: Display the `theme-showcase.pdf` file to allow users to see all available themes visually. Do not make any modifications to it; simply show the file for viewing.
+2. **Ask for their choice**: Ask which theme to apply to the deck
+3. **Wait for selection**: Get explicit confirmation about the chosen theme
+4. **Apply the theme**: Once a theme has been chosen, apply the selected theme's colors and fonts to the deck/artifact
+
+## Themes Available
+
+The following 10 themes are available, each showcased in `theme-showcase.pdf`:
+
+1. **Ocean Depths** - Professional and calming maritime theme
+2. **Sunset Boulevard** - Warm and vibrant sunset colors
+3. **Forest Canopy** - Natural and grounded earth tones
+4. **Modern Minimalist** - Clean and contemporary grayscale
+5. **Golden Hour** - Rich and warm autumnal palette
+6. **Arctic Frost** - Cool and crisp winter-inspired theme
+7. **Desert Rose** - Soft and sophisticated dusty tones
+8. **Tech Innovation** - Bold and modern tech aesthetic
+9. **Botanical Garden** - Fresh and organic garden colors
+10. **Midnight Galaxy** - Dramatic and cosmic deep tones
+
+## Theme Details
+
+Each theme is defined in the `themes/` directory with complete specifications including:
+- Cohesive color palette with hex codes
+- Complementary font pairings for headers and body text
+- Distinct visual identity suitable for different contexts and audiences
+
+## Application Process
+
+After a preferred theme is selected:
+1. Read the corresponding theme file from the `themes/` directory
+2. Apply the specified colors and fonts consistently throughout the deck
+3. Ensure proper contrast and readability
+4. Maintain the theme's visual identity across all slides
+
+## Create your Own Theme
+To handle cases where none of the existing themes work for an artifact, create a custom theme. Based on provided inputs, generate a new theme similar to the ones above. Give the theme a similar name describing what the font/color combinations represent. Use any basic description provided to choose appropriate colors/fonts. After generating the theme, show it for review and verification. Following that, apply the theme as described above.

adapters-output/codebuddy/theme-factory/workflows/theme-factory.json

@@ -0,0 +1,117 @@
+{
+  "id": "theme-factory",
+  "name": "Theme Factory Skill",
+  "description": "Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**Show the theme showcase**",
+      "description": "**Show the theme showcase**: Display the `theme-showcase.pdf` file to allow users to see all available themes visually. Do not make any modifications to it; simply show the file for viewing.",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**Ask for their choice**",
+      "description": "**Ask for their choice**: Ask which theme to apply to the deck",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**Wait for selection**",
+      "description": "**Wait for selection**: Get explicit confirmation about the chosen theme",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**Apply the theme**",
+      "description": "**Apply the theme**: Once a theme has been chosen, apply the selected theme's colors and fonts to the deck/artifact",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**Ocean Depths** - Professional and calming maritime theme",
+      "description": "**Ocean Depths** - Professional and calming maritime theme",
+      "type": "instruction"
+    },
+    {
+      "id": 6,
+      "name": "**Sunset Boulevard** - Warm and vibrant sunset colors",
+      "description": "**Sunset Boulevard** - Warm and vibrant sunset colors",
+      "type": "instruction"
+    },
+    {
+      "id": 7,
+      "name": "**Forest Canopy** - Natural and grounded earth tones",
+      "description": "**Forest Canopy** - Natural and grounded earth tones",
+      "type": "instruction"
+    },
+    {
+      "id": 8,
+      "name": "**Modern Minimalist** - Clean and contemporary grayscale",
+      "description": "**Modern Minimalist** - Clean and contemporary grayscale",
+      "type": "instruction"
+    },
+    {
+      "id": 9,
+      "name": "**Golden Hour** - Rich and warm autumnal palette",
+      "description": "**Golden Hour** - Rich and warm autumnal palette",
+      "type": "instruction"
+    },
+    {
+      "id": 10,
+      "name": "**Arctic Frost** - Cool and crisp winter-inspired theme",
+      "description": "**Arctic Frost** - Cool and crisp winter-inspired theme",
+      "type": "instruction"
+    },
+    {
+      "id": 11,
+      "name": "**Desert Rose** - Soft and sophisticated dusty tones",
+      "description": "**Desert Rose** - Soft and sophisticated dusty tones",
+      "type": "instruction"
+    },
+    {
+      "id": 12,
+      "name": "**Tech Innovation** - Bold and modern tech aesthetic",
+      "description": "**Tech Innovation** - Bold and modern tech aesthetic",
+      "type": "instruction"
+    },
+    {
+      "id": 13,
+      "name": "**Botanical Garden** - Fresh and organic garden colors",
+      "description": "**Botanical Garden** - Fresh and organic garden colors",
+      "type": "instruction"
+    },
+    {
+      "id": 14,
+      "name": "**Midnight Galaxy** - Dramatic and cosmic deep tones",
+      "description": "**Midnight Galaxy** - Dramatic and cosmic deep tones",
+      "type": "instruction"
+    },
+    {
+      "id": 15,
+      "name": "Read the corresponding theme file from the `themes/` directory",
+      "description": "Read the corresponding theme file from the `themes/` directory",
+      "type": "instruction"
+    },
+    {
+      "id": 16,
+      "name": "Apply the specified colors and fonts consistently throughout the deck",
+      "description": "Apply the specified colors and fonts consistently throughout the deck",
+      "type": "instruction"
+    },
+    {
+      "id": 17,
+      "name": "Ensure proper contrast and readability",
+      "description": "Ensure proper contrast and readability",
+      "type": "instruction"
+    },
+    {
+      "id": 18,
+      "name": "Maintain the theme's visual identity across all slides",
+      "description": "Maintain the theme's visual identity across all slides",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/web-artifacts-builder/manifest.json

@@ -0,0 +1,48 @@
+{
+  "name": "web-artifacts-builder",
+  "version": "1.0.0",
+  "description": "Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "web-artifacts-builder",
+      "name": "Web Artifacts Builder",
+      "description": "Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "Initialize the frontend repo using `scripts/init-artifact.sh`",
+          "description": "Initialize the frontend repo using `scripts/init-artifact.sh`",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "Develop your artifact by editing the generated code",
+          "description": "Develop your artifact by editing the generated code",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "Bundle all code into a single HTML file using `scripts/bundle-artifact.sh`",
+          "description": "Bundle all code into a single HTML file using `scripts/bundle-artifact.sh`",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "Display artifact to user",
+          "description": "Display artifact to user",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "(Optional) Test the artifact",
+          "description": "(Optional) Test the artifact",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/web-artifacts-builder/skills/web-artifacts-builder/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: web-artifacts-builder
+description: Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.
+license: Complete terms in LICENSE.txt
+---
+
+# Web Artifacts Builder
+
+To build powerful frontend claude.ai artifacts, follow these steps:
+1. Initialize the frontend repo using `scripts/init-artifact.sh`
+2. Develop your artifact by editing the generated code
+3. Bundle all code into a single HTML file using `scripts/bundle-artifact.sh`
+4. Display artifact to user
+5. (Optional) Test the artifact
+
+**Stack**: React 18 + TypeScript + Vite + Parcel (bundling) + Tailwind CSS + shadcn/ui
+
+## Design & Style Guidelines
+
+VERY IMPORTANT: To avoid what is often referred to as "AI slop", avoid using excessive centered layouts, purple gradients, uniform rounded corners, and Inter font.
+
+## Quick Start
+
+### Step 1: Initialize Project
+
+Run the initialization script to create a new React project:
+```bash
+bash scripts/init-artifact.sh <project-name>
+cd <project-name>
+```
+
+This creates a fully configured project with:
+- ✅ React + TypeScript (via Vite)
+- ✅ Tailwind CSS 3.4.1 with shadcn/ui theming system
+- ✅ Path aliases (`@/`) configured
+- ✅ 40+ shadcn/ui components pre-installed
+- ✅ All Radix UI dependencies included
+- ✅ Parcel configured for bundling (via .parcelrc)
+- ✅ Node 18+ compatibility (auto-detects and pins Vite version)
+
+### Step 2: Develop Your Artifact
+
+To build the artifact, edit the generated files. See **Common Development Tasks** below for guidance.
+
+### Step 3: Bundle to Single HTML File
+
+To bundle the React app into a single HTML artifact:
+```bash
+bash scripts/bundle-artifact.sh
+```
+
+This creates `bundle.html` - a self-contained artifact with all JavaScript, CSS, and dependencies inlined. This file can be directly shared in Claude conversations as an artifact.
+
+**Requirements**: Your project must have an `index.html` in the root directory.
+
+**What the script does**:
+- Installs bundling dependencies (parcel, @parcel/config-default, parcel-resolver-tspaths, html-inline)
+- Creates `.parcelrc` config with path alias support
+- Builds with Parcel (no source maps)
+- Inlines all assets into single HTML using html-inline
+
+### Step 4: Share Artifact with User
+
+Finally, share the bundled HTML file in conversation with the user so they can view it as an artifact.
+
+### Step 5: Testing/Visualizing the Artifact (Optional)
+
+Note: This is a completely optional step. Only perform if necessary or requested.
+
+To test/visualize the artifact, use available tools (including other Skills or built-in tools like Playwright or Puppeteer). In general, avoid testing the artifact upfront as it adds latency between the request and when the finished artifact can be seen. Test later, after presenting the artifact, if requested or if issues arise.
+
+## Reference
+
+- **shadcn/ui components**: https://ui.shadcn.com/docs/components

adapters-output/codebuddy/web-artifacts-builder/workflows/web-artifacts-builder.json

@@ -0,0 +1,39 @@
+{
+  "id": "web-artifacts-builder",
+  "name": "Web Artifacts Builder",
+  "description": "Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "Initialize the frontend repo using `scripts/init-artifact.sh`",
+      "description": "Initialize the frontend repo using `scripts/init-artifact.sh`",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "Develop your artifact by editing the generated code",
+      "description": "Develop your artifact by editing the generated code",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "Bundle all code into a single HTML file using `scripts/bundle-artifact.sh`",
+      "description": "Bundle all code into a single HTML file using `scripts/bundle-artifact.sh`",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "Display artifact to user",
+      "description": "Display artifact to user",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "(Optional) Test the artifact",
+      "description": "(Optional) Test the artifact",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/webapp-testing/manifest.json

@@ -0,0 +1,60 @@
+{
+  "name": "webapp-testing",
+  "version": "1.0.0",
+  "description": "Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "webapp-testing",
+      "name": "Web Application Testing",
+      "description": "Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.",
+      "steps": [
+        {
+          "id": 1,
+          "name": "Navigate and wait for networkidle",
+          "description": "Navigate and wait for networkidle",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "Take screenshot or inspect DOM",
+          "description": "Take screenshot or inspect DOM",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "Identify selectors from rendered state",
+          "description": "Identify selectors from rendered state",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "Execute actions with discovered selectors",
+          "description": "Execute actions with discovered selectors",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**Inspect rendered DOM**",
+          "description": "**Inspect rendered DOM**:",
+          "type": "instruction"
+        },
+        {
+          "id": 6,
+          "name": "**Identify selectors** from inspection results",
+          "description": "**Identify selectors** from inspection results",
+          "type": "instruction"
+        },
+        {
+          "id": 7,
+          "name": "**Execute actions** using discovered selectors",
+          "description": "**Execute actions** using discovered selectors",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/webapp-testing/skills/webapp-testing/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: webapp-testing
+description: Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.
+license: Complete terms in LICENSE.txt
+---
+
+# Web Application Testing
+
+To test local web applications, write native Python Playwright scripts.
+
+**Helper Scripts Available**:
+- `scripts/with_server.py` - Manages server lifecycle (supports multiple servers)
+
+**Always run scripts with `--help` first** to see usage. DO NOT read the source until you try running the script first and find that a customized solution is abslutely necessary. These scripts can be very large and thus pollute your context window. They exist to be called directly as black-box scripts rather than ingested into your context window.
+
+## Decision Tree: Choosing Your Approach
+
+```
+User task → Is it static HTML?
+    ├─ Yes → Read HTML file directly to identify selectors
+    │         ├─ Success → Write Playwright script using selectors
+    │         └─ Fails/Incomplete → Treat as dynamic (below)
+    │
+    └─ No (dynamic webapp) → Is the server already running?
+        ├─ No → Run: python scripts/with_server.py --help
+        │        Then use the helper + write simplified Playwright script
+        │
+        └─ Yes → Reconnaissance-then-action:
+            1. Navigate and wait for networkidle
+            2. Take screenshot or inspect DOM
+            3. Identify selectors from rendered state
+            4. Execute actions with discovered selectors
+```
+
+## Example: Using with_server.py
+
+To start a server, run `--help` first, then use the helper:
+
+**Single server:**
+```bash
+python scripts/with_server.py --server "npm run dev" --port 5173 -- python your_automation.py
+```
+
+**Multiple servers (e.g., backend + frontend):**
+```bash
+python scripts/with_server.py \
+  --server "cd backend && python server.py" --port 3000 \
+  --server "cd frontend && npm run dev" --port 5173 \
+  -- python your_automation.py
+```
+
+To create an automation script, include only Playwright logic (servers are managed automatically):
+```python
+from playwright.sync_api import sync_playwright
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True) # Always launch chromium in headless mode
+    page = browser.new_page()
+    page.goto('http://localhost:5173') # Server already running and ready
+    page.wait_for_load_state('networkidle') # CRITICAL: Wait for JS to execute
+    # ... your automation logic
+    browser.close()
+```
+
+## Reconnaissance-Then-Action Pattern
+
+1. **Inspect rendered DOM**:
+   ```python
+   page.screenshot(path='/tmp/inspect.png', full_page=True)
+   content = page.content()
+   page.locator('button').all()
+   ```
+
+2. **Identify selectors** from inspection results
+
+3. **Execute actions** using discovered selectors
+
+## Common Pitfall
+
+❌ **Don't** inspect the DOM before waiting for `networkidle` on dynamic apps
+✅ **Do** wait for `page.wait_for_load_state('networkidle')` before inspection
+
+## Best Practices
+
+- **Use bundled scripts as black boxes** - To accomplish a task, consider whether one of the scripts available in `scripts/` can help. These scripts handle common, complex workflows reliably without cluttering the context window. Use `--help` to see usage, then invoke directly. 
+- Use `sync_playwright()` for synchronous scripts
+- Always close the browser when done
+- Use descriptive selectors: `text=`, `role=`, CSS selectors, or IDs
+- Add appropriate waits: `page.wait_for_selector()` or `page.wait_for_timeout()`
+
+## Reference Files
+
+- **examples/** - Examples showing common patterns:
+  - `element_discovery.py` - Discovering buttons, links, and inputs on a page
+  - `static_html_automation.py` - Using file:// URLs for local HTML
+  - `console_logging.py` - Capturing console logs during automation

adapters-output/codebuddy/webapp-testing/workflows/webapp-testing.json

@@ -0,0 +1,51 @@
+{
+  "id": "webapp-testing",
+  "name": "Web Application Testing",
+  "description": "Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.",
+  "steps": [
+    {
+      "id": 1,
+      "name": "Navigate and wait for networkidle",
+      "description": "Navigate and wait for networkidle",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "Take screenshot or inspect DOM",
+      "description": "Take screenshot or inspect DOM",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "Identify selectors from rendered state",
+      "description": "Identify selectors from rendered state",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "Execute actions with discovered selectors",
+      "description": "Execute actions with discovered selectors",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**Inspect rendered DOM**",
+      "description": "**Inspect rendered DOM**:",
+      "type": "instruction"
+    },
+    {
+      "id": 6,
+      "name": "**Identify selectors** from inspection results",
+      "description": "**Identify selectors** from inspection results",
+      "type": "instruction"
+    },
+    {
+      "id": 7,
+      "name": "**Execute actions** using discovered selectors",
+      "description": "**Execute actions** using discovered selectors",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/xlsx/manifest.json

@@ -0,0 +1,54 @@
+{
+  "name": "xlsx",
+  "version": "1.0.0",
+  "description": "Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modify existing spreadsheets while preserving formulas, (4) Data analysis and visualization in spreadsheets, or (5) Recalculating formulas",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "xlsx",
+      "name": "Requirements for Outputs",
+      "description": "Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modify existing spreadsheets while preserving formulas, (4) Data analysis and visualization in spreadsheets, or (5) Recalculating formulas",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**Choose tool**",
+          "description": "**Choose tool**: pandas for data, openpyxl for formulas/formatting",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**Create/Load**",
+          "description": "**Create/Load**: Create new workbook or load existing file",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**Modify**",
+          "description": "**Modify**: Add/edit data, formulas, and formatting",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "**Save**",
+          "description": "**Save**: Write to file",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "**Recalculate formulas (MANDATORY IF USING FORMULAS)**",
+          "description": "**Recalculate formulas (MANDATORY IF USING FORMULAS)**: Use the recalc.py script",
+          "type": "instruction"
+        },
+        {
+          "id": 6,
+          "name": "**Verify and fix any errors**",
+          "description": "**Verify and fix any errors**:",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/xlsx/skills/xlsx/SKILL.md

@@ -0,0 +1,289 @@
+---
+name: xlsx
+description: "Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modify existing spreadsheets while preserving formulas, (4) Data analysis and visualization in spreadsheets, or (5) Recalculating formulas"
+license: Proprietary. LICENSE.txt has complete terms
+---
+
+# Requirements for Outputs
+
+## All Excel files
+
+### Zero Formula Errors
+- Every Excel model MUST be delivered with ZERO formula errors (#REF!, #DIV/0!, #VALUE!, #N/A, #NAME?)
+
+### Preserve Existing Templates (when updating templates)
+- Study and EXACTLY match existing format, style, and conventions when modifying files
+- Never impose standardized formatting on files with established patterns
+- Existing template conventions ALWAYS override these guidelines
+
+## Financial models
+
+### Color Coding Standards
+Unless otherwise stated by the user or existing template
+
+#### Industry-Standard Color Conventions
+- **Blue text (RGB: 0,0,255)**: Hardcoded inputs, and numbers users will change for scenarios
+- **Black text (RGB: 0,0,0)**: ALL formulas and calculations
+- **Green text (RGB: 0,128,0)**: Links pulling from other worksheets within same workbook
+- **Red text (RGB: 255,0,0)**: External links to other files
+- **Yellow background (RGB: 255,255,0)**: Key assumptions needing attention or cells that need to be updated
+
+### Number Formatting Standards
+
+#### Required Format Rules
+- **Years**: Format as text strings (e.g., "2024" not "2,024")
+- **Currency**: Use $#,##0 format; ALWAYS specify units in headers ("Revenue ($mm)")
+- **Zeros**: Use number formatting to make all zeros "-", including percentages (e.g., "$#,##0;($#,##0);-")
+- **Percentages**: Default to 0.0% format (one decimal)
+- **Multiples**: Format as 0.0x for valuation multiples (EV/EBITDA, P/E)
+- **Negative numbers**: Use parentheses (123) not minus -123
+
+### Formula Construction Rules
+
+#### Assumptions Placement
+- Place ALL assumptions (growth rates, margins, multiples, etc.) in separate assumption cells
+- Use cell references instead of hardcoded values in formulas
+- Example: Use =B5*(1+$B$6) instead of =B5*1.05
+
+#### Formula Error Prevention
+- Verify all cell references are correct
+- Check for off-by-one errors in ranges
+- Ensure consistent formulas across all projection periods
+- Test with edge cases (zero values, negative numbers)
+- Verify no unintended circular references
+
+#### Documentation Requirements for Hardcodes
+- Comment or in cells beside (if end of table). Format: "Source: [System/Document], [Date], [Specific Reference], [URL if applicable]"
+- Examples:
+  - "Source: Company 10-K, FY2024, Page 45, Revenue Note, [SEC EDGAR URL]"
+  - "Source: Company 10-Q, Q2 2025, Exhibit 99.1, [SEC EDGAR URL]"
+  - "Source: Bloomberg Terminal, 8/15/2025, AAPL US Equity"
+  - "Source: FactSet, 8/20/2025, Consensus Estimates Screen"
+
+# XLSX creation, editing, and analysis
+
+## Overview
+
+A user may ask you to create, edit, or analyze the contents of an .xlsx file. You have different tools and workflows available for different tasks.
+
+## Important Requirements
+
+**LibreOffice Required for Formula Recalculation**: You can assume LibreOffice is installed for recalculating formula values using the `recalc.py` script. The script automatically configures LibreOffice on first run
+
+## Reading and analyzing data
+
+### Data analysis with pandas
+For data analysis, visualization, and basic operations, use **pandas** which provides powerful data manipulation capabilities:
+
+```python
+import pandas as pd
+
+# Read Excel
+df = pd.read_excel('file.xlsx')  # Default: first sheet
+all_sheets = pd.read_excel('file.xlsx', sheet_name=None)  # All sheets as dict
+
+# Analyze
+df.head()      # Preview data
+df.info()      # Column info
+df.describe()  # Statistics
+
+# Write Excel
+df.to_excel('output.xlsx', index=False)
+```
+
+## Excel File Workflows
+
+## CRITICAL: Use Formulas, Not Hardcoded Values
+
+**Always use Excel formulas instead of calculating values in Python and hardcoding them.** This ensures the spreadsheet remains dynamic and updateable.
+
+### ❌ WRONG - Hardcoding Calculated Values
+```python
+# Bad: Calculating in Python and hardcoding result
+total = df['Sales'].sum()
+sheet['B10'] = total  # Hardcodes 5000
+
+# Bad: Computing growth rate in Python
+growth = (df.iloc[-1]['Revenue'] - df.iloc[0]['Revenue']) / df.iloc[0]['Revenue']
+sheet['C5'] = growth  # Hardcodes 0.15
+
+# Bad: Python calculation for average
+avg = sum(values) / len(values)
+sheet['D20'] = avg  # Hardcodes 42.5
+```
+
+### ✅ CORRECT - Using Excel Formulas
+```python
+# Good: Let Excel calculate the sum
+sheet['B10'] = '=SUM(B2:B9)'
+
+# Good: Growth rate as Excel formula
+sheet['C5'] = '=(C4-C2)/C2'
+
+# Good: Average using Excel function
+sheet['D20'] = '=AVERAGE(D2:D19)'
+```
+
+This applies to ALL calculations - totals, percentages, ratios, differences, etc. The spreadsheet should be able to recalculate when source data changes.
+
+## Common Workflow
+1. **Choose tool**: pandas for data, openpyxl for formulas/formatting
+2. **Create/Load**: Create new workbook or load existing file
+3. **Modify**: Add/edit data, formulas, and formatting
+4. **Save**: Write to file
+5. **Recalculate formulas (MANDATORY IF USING FORMULAS)**: Use the recalc.py script
+   ```bash
+   python recalc.py output.xlsx
+   ```
+6. **Verify and fix any errors**: 
+   - The script returns JSON with error details
+   - If `status` is `errors_found`, check `error_summary` for specific error types and locations
+   - Fix the identified errors and recalculate again
+   - Common errors to fix:
+     - `#REF!`: Invalid cell references
+     - `#DIV/0!`: Division by zero
+     - `#VALUE!`: Wrong data type in formula
+     - `#NAME?`: Unrecognized formula name
+
+### Creating new Excel files
+
+```python
+# Using openpyxl for formulas and formatting
+from openpyxl import Workbook
+from openpyxl.styles import Font, PatternFill, Alignment
+
+wb = Workbook()
+sheet = wb.active
+
+# Add data
+sheet['A1'] = 'Hello'
+sheet['B1'] = 'World'
+sheet.append(['Row', 'of', 'data'])
+
+# Add formula
+sheet['B2'] = '=SUM(A1:A10)'
+
+# Formatting
+sheet['A1'].font = Font(bold=True, color='FF0000')
+sheet['A1'].fill = PatternFill('solid', start_color='FFFF00')
+sheet['A1'].alignment = Alignment(horizontal='center')
+
+# Column width
+sheet.column_dimensions['A'].width = 20
+
+wb.save('output.xlsx')
+```
+
+### Editing existing Excel files
+
+```python
+# Using openpyxl to preserve formulas and formatting
+from openpyxl import load_workbook
+
+# Load existing file
+wb = load_workbook('existing.xlsx')
+sheet = wb.active  # or wb['SheetName'] for specific sheet
+
+# Working with multiple sheets
+for sheet_name in wb.sheetnames:
+    sheet = wb[sheet_name]
+    print(f"Sheet: {sheet_name}")
+
+# Modify cells
+sheet['A1'] = 'New Value'
+sheet.insert_rows(2)  # Insert row at position 2
+sheet.delete_cols(3)  # Delete column 3
+
+# Add new sheet
+new_sheet = wb.create_sheet('NewSheet')
+new_sheet['A1'] = 'Data'
+
+wb.save('modified.xlsx')
+```
+
+## Recalculating formulas
+
+Excel files created or modified by openpyxl contain formulas as strings but not calculated values. Use the provided `recalc.py` script to recalculate formulas:
+
+```bash
+python recalc.py <excel_file> [timeout_seconds]
+```
+
+Example:
+```bash
+python recalc.py output.xlsx 30
+```
+
+The script:
+- Automatically sets up LibreOffice macro on first run
+- Recalculates all formulas in all sheets
+- Scans ALL cells for Excel errors (#REF!, #DIV/0!, etc.)
+- Returns JSON with detailed error locations and counts
+- Works on both Linux and macOS
+
+## Formula Verification Checklist
+
+Quick checks to ensure formulas work correctly:
+
+### Essential Verification
+- [ ] **Test 2-3 sample references**: Verify they pull correct values before building full model
+- [ ] **Column mapping**: Confirm Excel columns match (e.g., column 64 = BL, not BK)
+- [ ] **Row offset**: Remember Excel rows are 1-indexed (DataFrame row 5 = Excel row 6)
+
+### Common Pitfalls
+- [ ] **NaN handling**: Check for null values with `pd.notna()`
+- [ ] **Far-right columns**: FY data often in columns 50+ 
+- [ ] **Multiple matches**: Search all occurrences, not just first
+- [ ] **Division by zero**: Check denominators before using `/` in formulas (#DIV/0!)
+- [ ] **Wrong references**: Verify all cell references point to intended cells (#REF!)
+- [ ] **Cross-sheet references**: Use correct format (Sheet1!A1) for linking sheets
+
+### Formula Testing Strategy
+- [ ] **Start small**: Test formulas on 2-3 cells before applying broadly
+- [ ] **Verify dependencies**: Check all cells referenced in formulas exist
+- [ ] **Test edge cases**: Include zero, negative, and very large values
+
+### Interpreting recalc.py Output
+The script returns JSON with error details:
+```json
+{
+  "status": "success",           // or "errors_found"
+  "total_errors": 0,              // Total error count
+  "total_formulas": 42,           // Number of formulas in file
+  "error_summary": {              // Only present if errors found
+    "#REF!": {
+      "count": 2,
+      "locations": ["Sheet1!B5", "Sheet1!C10"]
+    }
+  }
+}
+```
+
+## Best Practices
+
+### Library Selection
+- **pandas**: Best for data analysis, bulk operations, and simple data export
+- **openpyxl**: Best for complex formatting, formulas, and Excel-specific features
+
+### Working with openpyxl
+- Cell indices are 1-based (row=1, column=1 refers to cell A1)
+- Use `data_only=True` to read calculated values: `load_workbook('file.xlsx', data_only=True)`
+- **Warning**: If opened with `data_only=True` and saved, formulas are replaced with values and permanently lost
+- For large files: Use `read_only=True` for reading or `write_only=True` for writing
+- Formulas are preserved but not evaluated - use recalc.py to update values
+
+### Working with pandas
+- Specify data types to avoid inference issues: `pd.read_excel('file.xlsx', dtype={'id': str})`
+- For large files, read specific columns: `pd.read_excel('file.xlsx', usecols=['A', 'C', 'E'])`
+- Handle dates properly: `pd.read_excel('file.xlsx', parse_dates=['date_column'])`
+
+## Code Style Guidelines
+**IMPORTANT**: When generating Python code for Excel operations:
+- Write minimal, concise Python code without unnecessary comments
+- Avoid verbose variable names and redundant operations
+- Avoid unnecessary print statements
+
+**For Excel files themselves**:
+- Add comments to cells with complex formulas or important assumptions
+- Document data sources for hardcoded values
+- Include notes for key calculations and model sections

adapters-output/codebuddy/xlsx/workflows/xlsx.json

@@ -0,0 +1,45 @@
+{
+  "id": "xlsx",
+  "name": "Requirements for Outputs",
+  "description": "Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modify existing spreadsheets while preserving formulas, (4) Data analysis and visualization in spreadsheets, or (5) Recalculating formulas",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**Choose tool**",
+      "description": "**Choose tool**: pandas for data, openpyxl for formulas/formatting",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**Create/Load**",
+      "description": "**Create/Load**: Create new workbook or load existing file",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**Modify**",
+      "description": "**Modify**: Add/edit data, formulas, and formatting",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "**Save**",
+      "description": "**Save**: Write to file",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "**Recalculate formulas (MANDATORY IF USING FORMULAS)**",
+      "description": "**Recalculate formulas (MANDATORY IF USING FORMULAS)**: Use the recalc.py script",
+      "type": "instruction"
+    },
+    {
+      "id": 6,
+      "name": "**Verify and fix any errors**",
+      "description": "**Verify and fix any errors**:",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/codebuddy/zh-product-doc-generator/manifest.json

@@ -0,0 +1,198 @@
+{
+  "name": "zh-product-doc-generator",
+  "version": "1.0.0",
+  "description": "基于标准模板快速生成项目文档，包括产品调研、需求分析、PRD、架构设计、技术文档等13种项目交付文档模板。适用于软件开发项目的全生命周期文档生成。",
+  "author": "Teaching AI",
+  "type": "workflow-plugin",
+  "workflows": [
+    {
+      "id": "zh-product-doc-generator",
+      "name": "项目文档生成技能",
+      "description": "基于标准模板快速生成项目文档，包括产品调研、需求分析、PRD、架构设计、技术文档等13种项目交付文档模板。适用于软件开发项目的全生命周期文档生成。",
+      "steps": [
+        {
+          "id": 1,
+          "name": "**指定文档类型**",
+          "description": "**指定文档类型**",
+          "type": "instruction"
+        },
+        {
+          "id": 2,
+          "name": "**指定项目信息**",
+          "description": "**指定项目信息**",
+          "type": "instruction"
+        },
+        {
+          "id": 3,
+          "name": "**批量生成文档**",
+          "description": "**批量生成文档**",
+          "type": "instruction"
+        },
+        {
+          "id": 4,
+          "name": "`1、产品调研模板.md` - 产品调研阶段文档",
+          "description": "`1、产品调研模板.md` - 产品调研阶段文档",
+          "type": "instruction"
+        },
+        {
+          "id": 5,
+          "name": "`2、需求调研模板.md` - 需求调研阶段文档",
+          "description": "`2、需求调研模板.md` - 需求调研阶段文档",
+          "type": "instruction"
+        },
+        {
+          "id": 6,
+          "name": "`3、技术调研模板.md` - 技术调研阶段文档（技术选型、技术可行性分析）",
+          "description": "`3、技术调研模板.md` - 技术调研阶段文档（技术选型、技术可行性分析）",
+          "type": "instruction"
+        },
+        {
+          "id": 7,
+          "name": "`4、需求分析模板.md` - 需求分析阶段文档",
+          "description": "`4、需求分析模板.md` - 需求分析阶段文档",
+          "type": "instruction"
+        },
+        {
+          "id": 8,
+          "name": "`5、PRD文档模板.md` - 产品需求文档",
+          "description": "`5、PRD文档模板.md` - 产品需求文档",
+          "type": "instruction"
+        },
+        {
+          "id": 9,
+          "name": "`6、视觉与交互 DNA 规范模板.md` - 设计规范文档",
+          "description": "`6、视觉与交互 DNA 规范模板.md` - 设计规范文档",
+          "type": "instruction"
+        },
+        {
+          "id": 10,
+          "name": "`7、UI 设计说明模板.md` - UI设计文档",
+          "description": "`7、UI 设计说明模板.md` - UI设计文档",
+          "type": "instruction"
+        },
+        {
+          "id": 11,
+          "name": "`8、领域模型说明模板.md` - 领域模型文档",
+          "description": "`8、领域模型说明模板.md` - 领域模型文档",
+          "type": "instruction"
+        },
+        {
+          "id": 12,
+          "name": "`9、系统架构设计模板.md` - 系统架构文档",
+          "description": "`9、系统架构设计模板.md` - 系统架构文档",
+          "type": "instruction"
+        },
+        {
+          "id": 13,
+          "name": "`10、技术细分模板.md` - 技术实现文档",
+          "description": "`10、技术细分模板.md` - 技术实现文档",
+          "type": "instruction"
+        },
+        {
+          "id": 14,
+          "name": "`11、功能提测模板.md` - 提测文档",
+          "description": "`11、功能提测模板.md` - 提测文档",
+          "type": "instruction"
+        },
+        {
+          "id": 15,
+          "name": "`12、测试结果模板.md` - 测试报告",
+          "description": "`12、测试结果模板.md` - 测试报告",
+          "type": "instruction"
+        },
+        {
+          "id": 16,
+          "name": "`13、上线通知模板.md` - 上线文档",
+          "description": "`13、上线通知模板.md` - 上线文档",
+          "type": "instruction"
+        },
+        {
+          "id": 17,
+          "name": "`14、项目运维模板.md` - 运维文档",
+          "description": "`14、项目运维模板.md` - 运维文档",
+          "type": "instruction"
+        },
+        {
+          "id": 18,
+          "name": "**选择模板**",
+          "description": "**选择模板**",
+          "type": "instruction"
+        },
+        {
+          "id": 19,
+          "name": "**填写占位符**",
+          "description": "**填写占位符**",
+          "type": "instruction"
+        },
+        {
+          "id": 20,
+          "name": "**定制化调整**",
+          "description": "**定制化调整**",
+          "type": "instruction"
+        },
+        {
+          "id": 21,
+          "name": "**文档评审**",
+          "description": "**文档评审**",
+          "type": "instruction"
+        },
+        {
+          "id": 22,
+          "name": "产品调研文档",
+          "description": "产品调研文档",
+          "type": "instruction"
+        },
+        {
+          "id": 23,
+          "name": "PRD 文档",
+          "description": "PRD 文档",
+          "type": "instruction"
+        },
+        {
+          "id": 24,
+          "name": "系统架构设计文档",
+          "description": "系统架构设计文档",
+          "type": "instruction"
+        },
+        {
+          "id": 25,
+          "name": "技术细分文档",
+          "description": "技术细分文档",
+          "type": "instruction"
+        },
+        {
+          "id": 26,
+          "name": "**占位符替换**",
+          "description": "**占位符替换**: 确保所有 `{}` 占位符都被正确替换",
+          "type": "instruction"
+        },
+        {
+          "id": 27,
+          "name": "**文档关联**",
+          "description": "**文档关联**: 注意文档之间的关联关系，保持一致性",
+          "type": "instruction"
+        },
+        {
+          "id": 28,
+          "name": "**版本管理**",
+          "description": "**版本管理**: 使用版本记录表跟踪文档变更",
+          "type": "instruction"
+        },
+        {
+          "id": 29,
+          "name": "**团队协作**",
+          "description": "**团队协作**: 明确文档责任人，确保文档质量",
+          "type": "instruction"
+        },
+        {
+          "id": 30,
+          "name": "**持续更新**",
+          "description": "**持续更新**: 根据项目进展及时更新文档内容",
+          "type": "instruction"
+        }
+      ],
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}

adapters-output/codebuddy/zh-product-doc-generator/skills/zh-product-doc-generator/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: zh-product-doc-generator
+description: 基于标准模板快速生成项目文档，包括产品调研、需求分析、PRD、架构设计、技术文档等13种项目交付文档模板。适用于软件开发项目的全生命周期文档生成。
+---
+
+# 项目文档生成技能
+
+## 概述
+
+本技能提供了一套完整的项目文档模板集合，帮助快速生成软件开发项目所需的各种文档。模板基于 DDD（领域驱动设计）和 COLA 架构思想，适用于从产品调研到项目运维的全生命周期。
+
+**关键词**: 项目文档、PRD、需求文档、架构设计、技术文档、项目模板、文档生成、产品文档
+
+## 核心功能
+
+### 1. 产品阶段文档
+
+- **产品调研模板** - 市场调研、用户调研、竞品分析
+- **需求调研模板** - 需求收集、用户访谈、需求整理
+- **技术调研模板** - 技术选型、技术可行性分析、技术对比
+- **需求分析模板** - 需求拆解、优先级排序、需求评审
+
+### 2. 设计阶段文档
+
+- **PRD文档模板** - 产品需求文档，包含功能需求、用户故事、验收标准
+- **视觉与交互 DNA 规范模板** - 设计语言、交互规范、视觉规范
+- **UI 设计说明模板** - UI设计规范、组件库、设计系统
+
+### 3. 技术设计文档
+
+- **领域模型说明模板** - DDD领域模型、实体、值对象、聚合
+- **系统架构设计模板** - 技术架构、系统架构、部署架构
+- **技术细分模板** - 接口设计、数据库设计、技术实现细节
+
+### 4. 测试与交付文档
+
+- **功能提测模板** - 提测清单、测试环境、测试范围
+- **测试结果模板** - 测试报告、缺陷统计、测试结论
+- **上线通知模板** - 上线计划、上线检查清单、回滚方案
+- **项目运维模板** - 运维手册、监控告警、故障处理
+
+## 使用指南
+
+### 快速生成文档
+
+1. **指定文档类型**
+   ```
+   使用项目文档生成技能，帮我生成一个 PRD 文档
+   ```
+
+2. **指定项目信息**
+   ```
+   基于模板生成系统架构设计文档，项目名称是 TeachingAI 教学平台
+   ```
+
+3. **批量生成文档**
+   ```
+   为我的项目生成全套文档，包括 PRD、架构设计、技术文档
+   ```
+
+### 模板使用说明
+
+所有模板文件位于 `templates/` 目录下，包含以下14个模板：
+
+1. `1、产品调研模板.md` - 产品调研阶段文档
+2. `2、需求调研模板.md` - 需求调研阶段文档
+3. `3、技术调研模板.md` - 技术调研阶段文档（技术选型、技术可行性分析）
+4. `4、需求分析模板.md` - 需求分析阶段文档
+5. `5、PRD文档模板.md` - 产品需求文档
+6. `6、视觉与交互 DNA 规范模板.md` - 设计规范文档
+7. `7、UI 设计说明模板.md` - UI设计文档
+8. `8、领域模型说明模板.md` - 领域模型文档
+9. `9、系统架构设计模板.md` - 系统架构文档
+10. `10、技术细分模板.md` - 技术实现文档
+11. `11、功能提测模板.md` - 提测文档
+12. `12、测试结果模板.md` - 测试报告
+13. `13、上线通知模板.md` - 上线文档
+14. `14、项目运维模板.md` - 运维文档
+
+### 模板占位符说明
+
+模板中使用 `{}` 包裹的内容为占位符，需要替换为实际内容：
+
+- `{产品名称}` - 产品名称
+- `{项目名称}` - 项目名称
+- `{YYYY-MM-DD}` - 日期格式
+- `{姓名}` - 人员姓名
+- 其他 `{}` 包裹的内容 - 根据上下文替换
+
+### 文档生成流程
+
+1. **选择模板**
+   - 根据项目阶段选择合适的模板
+   - 可以同时使用多个模板生成完整文档集
+
+2. **填写占位符**
+   - 替换模板中的 `{}` 占位符
+   - 根据项目实际情况填写内容
+
+3. **定制化调整**
+   - 根据项目特点调整模板结构
+   - 添加或删除不需要的章节
+
+4. **文档评审**
+   - 与团队评审文档内容
+   - 根据反馈调整和完善
+
+## 使用示例
+
+### 示例 1: 生成 PRD 文档
+
+```
+用户: 使用项目文档生成技能，帮我生成一个 PRD 文档，产品名称是"智能教学助手"
+
+AI: 我将基于 PRD 文档模板为您生成产品需求文档...
+```
+
+### 示例 2: 生成架构设计文档
+
+```
+用户: 基于模板生成系统架构设计文档，项目名称是 TeachingAI 教学平台，使用 Spring Boot 和 Vue 3
+
+AI: 我将基于系统架构设计模板为您生成架构文档...
+```
+
+### 示例 3: 生成完整文档集
+
+```
+用户: 为我的新项目生成全套文档，包括产品调研、PRD、架构设计和技术文档
+
+AI: 我将为您生成以下文档：
+1. 产品调研文档
+2. PRD 文档
+3. 系统架构设计文档
+4. 技术细分文档
+...
+```
+
+## 模板特点
+
+### 1. 标准化结构
+
+- 统一的文档格式和结构
+- 清晰的章节划分
+- 完整的版本记录
+
+### 2. DDD 和 COLA 架构
+
+- 基于领域驱动设计思想
+- 遵循 COLA 架构原则
+- 支持微服务架构设计
+
+### 3. 全生命周期覆盖
+
+- 从产品调研到项目运维
+- 涵盖所有关键阶段
+- 文档之间相互关联
+
+### 4. 易于定制
+
+- 使用占位符便于替换
+- 结构清晰便于调整
+- 支持项目特定需求
+
+## 注意事项
+
+1. **占位符替换**: 确保所有 `{}` 占位符都被正确替换
+2. **文档关联**: 注意文档之间的关联关系，保持一致性
+3. **版本管理**: 使用版本记录表跟踪文档变更
+4. **团队协作**: 明确文档责任人，确保文档质量
+5. **持续更新**: 根据项目进展及时更新文档内容
+
+## 相关技能
+
+- `documentation-builder` - 通用文档构建技能
+- `code-generator` - 代码生成技能
+- `mcp-builder` - MCP 构建器技能
+
+## 参考资源
+
+- [DDD 领域驱动设计](https://domainlanguage.com/ddd/)
+- [COLA 架构](https://github.com/alibaba/COLA)
+- [产品文档最佳实践](https://www.atlassian.com/software/confluence)

adapters-output/codebuddy/zh-product-doc-generator/workflows/zh-product-doc-generator.json

@@ -0,0 +1,189 @@
+{
+  "id": "zh-product-doc-generator",
+  "name": "项目文档生成技能",
+  "description": "基于标准模板快速生成项目文档，包括产品调研、需求分析、PRD、架构设计、技术文档等13种项目交付文档模板。适用于软件开发项目的全生命周期文档生成。",
+  "steps": [
+    {
+      "id": 1,
+      "name": "**指定文档类型**",
+      "description": "**指定文档类型**",
+      "type": "instruction"
+    },
+    {
+      "id": 2,
+      "name": "**指定项目信息**",
+      "description": "**指定项目信息**",
+      "type": "instruction"
+    },
+    {
+      "id": 3,
+      "name": "**批量生成文档**",
+      "description": "**批量生成文档**",
+      "type": "instruction"
+    },
+    {
+      "id": 4,
+      "name": "`1、产品调研模板.md` - 产品调研阶段文档",
+      "description": "`1、产品调研模板.md` - 产品调研阶段文档",
+      "type": "instruction"
+    },
+    {
+      "id": 5,
+      "name": "`2、需求调研模板.md` - 需求调研阶段文档",
+      "description": "`2、需求调研模板.md` - 需求调研阶段文档",
+      "type": "instruction"
+    },
+    {
+      "id": 6,
+      "name": "`3、技术调研模板.md` - 技术调研阶段文档（技术选型、技术可行性分析）",
+      "description": "`3、技术调研模板.md` - 技术调研阶段文档（技术选型、技术可行性分析）",
+      "type": "instruction"
+    },
+    {
+      "id": 7,
+      "name": "`4、需求分析模板.md` - 需求分析阶段文档",
+      "description": "`4、需求分析模板.md` - 需求分析阶段文档",
+      "type": "instruction"
+    },
+    {
+      "id": 8,
+      "name": "`5、PRD文档模板.md` - 产品需求文档",
+      "description": "`5、PRD文档模板.md` - 产品需求文档",
+      "type": "instruction"
+    },
+    {
+      "id": 9,
+      "name": "`6、视觉与交互 DNA 规范模板.md` - 设计规范文档",
+      "description": "`6、视觉与交互 DNA 规范模板.md` - 设计规范文档",
+      "type": "instruction"
+    },
+    {
+      "id": 10,
+      "name": "`7、UI 设计说明模板.md` - UI设计文档",
+      "description": "`7、UI 设计说明模板.md` - UI设计文档",
+      "type": "instruction"
+    },
+    {
+      "id": 11,
+      "name": "`8、领域模型说明模板.md` - 领域模型文档",
+      "description": "`8、领域模型说明模板.md` - 领域模型文档",
+      "type": "instruction"
+    },
+    {
+      "id": 12,
+      "name": "`9、系统架构设计模板.md` - 系统架构文档",
+      "description": "`9、系统架构设计模板.md` - 系统架构文档",
+      "type": "instruction"
+    },
+    {
+      "id": 13,
+      "name": "`10、技术细分模板.md` - 技术实现文档",
+      "description": "`10、技术细分模板.md` - 技术实现文档",
+      "type": "instruction"
+    },
+    {
+      "id": 14,
+      "name": "`11、功能提测模板.md` - 提测文档",
+      "description": "`11、功能提测模板.md` - 提测文档",
+      "type": "instruction"
+    },
+    {
+      "id": 15,
+      "name": "`12、测试结果模板.md` - 测试报告",
+      "description": "`12、测试结果模板.md` - 测试报告",
+      "type": "instruction"
+    },
+    {
+      "id": 16,
+      "name": "`13、上线通知模板.md` - 上线文档",
+      "description": "`13、上线通知模板.md` - 上线文档",
+      "type": "instruction"
+    },
+    {
+      "id": 17,
+      "name": "`14、项目运维模板.md` - 运维文档",
+      "description": "`14、项目运维模板.md` - 运维文档",
+      "type": "instruction"
+    },
+    {
+      "id": 18,
+      "name": "**选择模板**",
+      "description": "**选择模板**",
+      "type": "instruction"
+    },
+    {
+      "id": 19,
+      "name": "**填写占位符**",
+      "description": "**填写占位符**",
+      "type": "instruction"
+    },
+    {
+      "id": 20,
+      "name": "**定制化调整**",
+      "description": "**定制化调整**",
+      "type": "instruction"
+    },
+    {
+      "id": 21,
+      "name": "**文档评审**",
+      "description": "**文档评审**",
+      "type": "instruction"
+    },
+    {
+      "id": 22,
+      "name": "产品调研文档",
+      "description": "产品调研文档",
+      "type": "instruction"
+    },
+    {
+      "id": 23,
+      "name": "PRD 文档",
+      "description": "PRD 文档",
+      "type": "instruction"
+    },
+    {
+      "id": 24,
+      "name": "系统架构设计文档",
+      "description": "系统架构设计文档",
+      "type": "instruction"
+    },
+    {
+      "id": 25,
+      "name": "技术细分文档",
+      "description": "技术细分文档",
+      "type": "instruction"
+    },
+    {
+      "id": 26,
+      "name": "**占位符替换**",
+      "description": "**占位符替换**: 确保所有 `{}` 占位符都被正确替换",
+      "type": "instruction"
+    },
+    {
+      "id": 27,
+      "name": "**文档关联**",
+      "description": "**文档关联**: 注意文档之间的关联关系，保持一致性",
+      "type": "instruction"
+    },
+    {
+      "id": 28,
+      "name": "**版本管理**",
+      "description": "**版本管理**: 使用版本记录表跟踪文档变更",
+      "type": "instruction"
+    },
+    {
+      "id": 29,
+      "name": "**团队协作**",
+      "description": "**团队协作**: 明确文档责任人，确保文档质量",
+      "type": "instruction"
+    },
+    {
+      "id": 30,
+      "name": "**持续更新**",
+      "description": "**持续更新**: 根据项目进展及时更新文档内容",
+      "type": "instruction"
+    }
+  ],
+  "inputs": [],
+  "outputs": []
+}

adapters-output/cursor/algorithmic-art.md

@@ -0,0 +1,409 @@
+# Algorithmic Art
+
+## Description
+Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
+
+## When to Use
+Use this skill when the user asks about: Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
+
+## Instructions
+
+Algorithmic philosophies are computational aesthetic movements that are then expressed through code. Output .md files (philosophy), .html files (interactive viewer), and .js files (generative algorithms).
+
+This happens in two steps:
+1. Algorithmic Philosophy Creation (.md file)
+2. Express by creating p5.js generative art (.html + .js files)
+
+First, undertake this task:
+
+## ALGORITHMIC PHILOSOPHY CREATION
+
+To begin, create an ALGORITHMIC PHILOSOPHY (not static images or templates) that will be interpreted through:
+- Computational processes, emergent behavior, mathematical beauty
+- Seeded randomness, noise fields, organic systems
+- Particles, flows, fields, forces
+- Parametric variation and controlled chaos
+
+### THE CRITICAL UNDERSTANDING
+- What is received: Some subtle input or instructions by the user to take into account, but use as a foundation; it should not constrain creative freedom.
+- What is created: An algorithmic philosophy/generative aesthetic movement.
+- What happens next: The same version receives the philosophy and EXPRESSES IT IN CODE - creating p5.js sketches that are 90% algorithmic generation, 10% essential parameters.
+
+Consider this approach:
+- Write a manifesto for a generative art movement
+- The next phase involves writing the algorithm that brings it to life
+
+The philosophy must emphasize: Algorithmic expression. Emergent behavior. Computational beauty. Seeded variation.
+
+### HOW TO GENERATE AN ALGORITHMIC PHILOSOPHY
+
+**Name the movement** (1-2 words): "Organic Turbulence" / "Quantum Harmonics" / "Emergent Stillness"
+
+**Articulate the philosophy** (4-6 paragraphs - concise but complete):
+
+To capture the ALGORITHMIC essence, express how this philosophy manifests through:
+- Computational processes and mathematical relationships?
+- Noise functions and randomness patterns?
+- Particle behaviors and field dynamics?
+- Temporal evolution and system states?
+- Parametric variation and emergent complexity?
+
+**CRITICAL GUIDELINES:**
+- **Avoid redundancy**: Each algorithmic aspect should be mentioned once. Avoid repeating concepts about noise theory, particle dynamics, or mathematical principles unless adding new depth.
+- **Emphasize craftsmanship REPEATEDLY**: The philosophy MUST stress multiple times that the final algorithm should appear as though it took countless hours to develop, was refined with care, and comes from someone at the absolute top of their field. This framing is essential - repeat phrases like "meticulously crafted algorithm," "the product of deep computational expertise," "painstaking optimization," "master-level implementation."
+- **Leave creative space**: Be specific about the algorithmic direction, but concise enough that the next Claude has room to make interpretive implementation choices at an extremely high level of craftsmanship.
+
+The philosophy must guide the next version to express ideas ALGORITHMICALLY, not through static images. Beauty lives in the process, not the final frame.
+
+### PHILOSOPHY EXAMPLES
+
+**"Organic Turbulence"**
+Philosophy: Chaos constrained by natural law, order emerging from disorder.
+Algorithmic expression: Flow fields driven by layered Perlin noise. Thousands of particles following vector forces, their trails accumulating into organic density maps. Multiple noise octaves create turbulent regions and calm zones. Color emerges from velocity and density - fast particles burn bright, slow ones fade to shadow. The algorithm runs until equilibrium - a meticulously tuned balance where every parameter was refined through countless iterations by a master of computational aesthetics.
+
+**"Quantum Harmonics"**
+Philosophy: Discrete entities exhibiting wave-like interference patterns.
+Algorithmic expression: Particles initialized on a grid, each carrying a phase value that evolves through sine waves. When particles are near, their phases interfere - constructive interference creates bright nodes, destructive creates voids. Simple harmonic motion generates complex emergent mandalas. The result of painstaking frequency calibration where every ratio was carefully chosen to produce resonant beauty.
+
+**"Recursive Whispers"**
+Philosophy: Self-similarity across scales, infinite depth in finite space.
+Algorithmic expression: Branching structures that subdivide recursively. Each branch slightly randomized but constrained by golden ratios. L-systems or recursive subdivision generate tree-like forms that feel both mathematical and organic. Subtle noise perturbations break perfect symmetry. Line weights diminish with each recursion level. Every branching angle the product of deep mathematical exploration.
+
+**"Field Dynamics"**
+Philosophy: Invisible forces made visible through their effects on matter.
+Algorithmic expression: Vector fields constructed from mathematical functions or noise. Particles born at edges, flowing along field lines, dying when they reach equilibrium or boundaries. Multiple fields can attract, repel, or rotate particles. The visualization shows only the traces - ghost-like evidence of invisible forces. A computational dance meticulously choreographed through force balance.
+
+**"Stochastic Crystallization"**
+Philosophy: Random processes crystallizing into ordered structures.
+Algorithmic expression: Randomized circle packing or Voronoi tessellation. Start with random points, let them evolve through relaxation algorithms. Cells push apart until equilibrium. Color based on cell size, neighbor count, or distance from center. The organic tiling that emerges feels both random and inevitable. Every seed produces unique crystalline beauty - the mark of a master-level generative algorithm.
+
+*These are condensed examples. The actual algorithmic philosophy should be 4-6 substantial paragraphs.*
+
+### ESSENTIAL PRINCIPLES
+- **ALGORITHMIC PHILOSOPHY**: Creating a computational worldview to be expressed through code
+- **PROCESS OVER PRODUCT**: Always emphasize that beauty emerges from the algorithm's execution - each run is unique
+- **PARAMETRIC EXPRESSION**: Ideas communicate through mathematical relationships, forces, behaviors - not static composition
+- **ARTISTIC FREEDOM**: The next Claude interprets the philosophy algorithmically - provide creative implementation room
+- **PURE GENERATIVE ART**: This is about making LIVING ALGORITHMS, not static images with randomness
+- **EXPERT CRAFTSMANSHIP**: Repeatedly emphasize the final algorithm must feel meticulously crafted, refined through countless iterations, the product of deep expertise by someone at the absolute top of their field in computational aesthetics
+
+**The algorithmic philosophy should be 4-6 paragraphs long.** Fill it with poetic computational philosophy that brings together the intended vision. Avoid repeating the same points. Output this algorithmic philosophy as a .md file.
+
+---
+
+## DEDUCING THE CONCEPTUAL SEED
+
+**CRITICAL STEP**: Before implementing the algorithm, identify the subtle conceptual thread from the original request.
+
+**THE ESSENTIAL PRINCIPLE**:
+The concept is a **subtle, niche reference embedded within the algorithm itself** - not always literal, always sophisticated. Someone familiar with the subject should feel it intuitively, while others simply experience a masterful generative composition. The algorithmic philosophy provides the computational language. The deduced concept provides the soul - the quiet conceptual DNA woven invisibly into parameters, behaviors, and emergence patterns.
+
+This is **VERY IMPORTANT**: The reference must be so refined that it enhances the work's depth without announcing itself. Think like a jazz musician quoting another song through algorithmic harmony - only those who know will catch it, but everyone appreciates the generative beauty.
+
+---
+
+## P5.JS IMPLEMENTATION
+
+With the philosophy AND conceptual framework established, express it through code. Pause to gather thoughts before proceeding. Use only the algorithmic philosophy created and the instructions below.
+
+### ⚠️ STEP 0: READ THE TEMPLATE FIRST ⚠️
+
+**CRITICAL: BEFORE writing any HTML:**
+
+1. **Read** `templates/viewer.html` using the Read tool
+2. **Study** the exact structure, styling, and Anthropic branding
+3. **Use that file as the LITERAL STARTING POINT** - not just inspiration
+4. **Keep all FIXED sections exactly as shown** (header, sidebar structure, Anthropic colors/fonts, seed controls, action buttons)
+5. **Replace only the VARIABLE sections** marked in the file's comments (algorithm, parameters, UI controls for parameters)
+
+**Avoid:**
+- ❌ Creating HTML from scratch
+- ❌ Inventing custom styling or color schemes
+- ❌ Using system fonts or dark themes
+- ❌ Changing the sidebar structure
+
+**Follow these practices:**
+- ✅ Copy the template's exact HTML structure
+- ✅ Keep Anthropic branding (Poppins/Lora fonts, light colors, gradient backdrop)
+- ✅ Maintain the sidebar layout (Seed → Parameters → Colors? → Actions)
+- ✅ Replace only the p5.js algorithm and parameter controls
+
+The template is the foundation. Build on it, don't rebuild it.
+
+---
+
+To create gallery-quality computational art that lives and breathes, use the algorithmic philosophy as the foundation.
+
+### TECHNICAL REQUIREMENTS
+
+**Seeded Randomness (Art Blocks Pattern)**:
+```javascript
+// ALWAYS use a seed for reproducibility
+let seed = 12345; // or hash from user input
+randomSeed(seed);
+noiseSeed(seed);
+```
+
+**Parameter Structure - FOLLOW THE PHILOSOPHY**:
+
+To establish parameters that emerge naturally from the algorithmic philosophy, consider: "What qualities of this system can be adjusted?"
+
+```javascript
+let params = {
+  seed: 12345,  // Always include seed for reproducibility
+  // colors
+  // Add parameters that control YOUR algorithm:
+  // - Quantities (how many?)
+  // - Scales (how big? how fast?)
+  // - Probabilities (how likely?)
+  // - Ratios (what proportions?)
+  // - Angles (what direction?)
+  // - Thresholds (when does behavior change?)
+};
+```
+
+**To design effective parameters, focus on the properties the system needs to be tunable rather than thinking in terms of "pattern types".**
+
+**Core Algorithm - EXPRESS THE PHILOSOPHY**:
+
+**CRITICAL**: The algorithmic philosophy should dictate what to build.
+
+To express the philosophy through code, avoid thinking "which pattern should I use?" and instead think "how to express this philosophy through code?"
+
+If the philosophy is about **organic emergence**, consider using:
+- Elements that accumulate or grow over time
+- Random processes constrained by natural rules
+- Feedback loops and interactions
+
+If the philosophy is about **mathematical beauty**, consider using:
+- Geometric relationships and ratios
+- Trigonometric functions and harmonics
+- Precise calculations creating unexpected patterns
+
+If the philosophy is about **controlled chaos**, consider using:
+- Random variation within strict boundaries
+- Bifurcation and phase transitions
+- Order emerging from disorder
+
+**The algorithm flows from the philosophy, not from a menu of options.**
+
+To guide the implementation, let the conceptual essence inform creative and original choices. Build something that expresses the vision for this particular request.
+
+**Canvas Setup**: Standard p5.js structure:
+```javascript
+function setup() {
+  createCanvas(1200, 1200);
+  // Initialize your system
+}
+
+function draw() {
+  // Your generative algorithm
+  // Can be static (noLoop) or animated
+}
+```
+
+### CRAFTSMANSHIP REQUIREMENTS
+
+**CRITICAL**: To achieve mastery, create algorithms that feel like they emerged through countless iterations by a master generative artist. Tune every parameter carefully. Ensure every pattern emerges with purpose. This is NOT random noise - this is CONTROLLED CHAOS refined through deep expertise.
+
+- **Balance**: Complexity without visual noise, order without rigidity
+- **Color Harmony**: Thoughtful palettes, not random RGB values
+- **Composition**: Even in randomness, maintain visual hierarchy and flow
+- **Performance**: Smooth execution, optimized for real-time if animated
+- **Reproducibility**: Same seed ALWAYS produces identical output
+
+### OUTPUT FORMAT
+
+Output:
+1. **Algorithmic Philosophy** - As markdown or text explaining the generative aesthetic
+2. **Single HTML Artifact** - Self-contained interactive generative art built from `templates/viewer.html` (see STEP 0 and next section)
+
+The HTML artifact contains everything: p5.js (from CDN), the algorithm, parameter controls, and UI - all in one file that works immediately in claude.ai artifacts or any browser. Start from the template file, not from scratch.
+
+---
+
+## INTERACTIVE ARTIFACT CREATION
+
+**REMINDER: `templates/viewer.html` should have already been read (see STEP 0). Use that file as the starting point.**
+
+To allow exploration of the generative art, create a single, self-contained HTML artifact. Ensure this artifact works immediately in claude.ai or any browser - no setup required. Embed everything inline.
+
+### CRITICAL: WHAT'S FIXED VS VARIABLE
+
+The `templates/viewer.html` file is the foundation. It contains the exact structure and styling needed.
+
+**FIXED (always include exactly as shown):**
+- Layout structure (header, sidebar, main canvas area)
+- Anthropic branding (UI colors, fonts, gradients)
+- Seed section in sidebar:
+  - Seed display
+  - Previous/Next buttons
+  - Random button
+  - Jump to seed input + Go button
+- Actions section in sidebar:
+  - Regenerate button
+  - Reset button
+
+**VARIABLE (customize for each artwork):**
+- The entire p5.js algorithm (setup/draw/classes)
+- The parameters object (define what the art needs)
+- The Parameters section in sidebar:
+  - Number of parameter controls
+  - Parameter names
+  - Min/max/step values for sliders
+  - Control types (sliders, inputs, etc.)
+- Colors section (optional):
+  - Some art needs color pickers
+  - Some art might use fixed colors
+  - Some art might be monochrome (no color controls needed)
+  - Decide based on the art's needs
+
+**Every artwork should have unique parameters and algorithm!** The fixed parts provide consistent UX - everything else expresses the unique vision.
+
+### REQUIRED FEATURES
+
+**1. Parameter Controls**
+- Sliders for numeric parameters (particle count, noise scale, speed, etc.)
+- Color pickers for palette colors
+- Real-time updates when parameters change
+- Reset button to restore defaults
+
+**2. Seed Navigation**
+- Display current seed number
+- "Previous" and "Next" buttons to cycle through seeds
+- "Random" button for random seed
+- Input field to jump to specific seed
+- Generate 100 variations when requested (seeds 1-100)
+
+**3. Single Artifact Structure**
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <!-- p5.js from CDN - always available -->
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/1.7.0/p5.min.js"></script>
+  <style>
+    /* All styling inline - clean, minimal */
+    /* Canvas on top, controls below */
+  </style>
+</head>
+<body>
+  <div id="canvas-container"></div>
+  <div id="controls">
+    <!-- All parameter controls -->
+  </div>
+  <script>
+    // ALL p5.js code inline here
+    // Parameter objects, classes, functions
+    // setup() and draw()
+    // UI handlers
+    // Everything self-contained
+  </script>
+</body>
+</html>
+```
+
+**CRITICAL**: This is a single artifact. No external files, no imports (except p5.js CDN). Everything inline.
+
+**4. Implementation Details - BUILD THE SIDEBAR**
+
+The sidebar structure:
+
+**1. Seed (FIXED)** - Always include exactly as shown:
+- Seed display
+- Prev/Next/Random/Jump buttons
+
+**2. Parameters (VARIABLE)** - Create controls for the art:
+```html
+<div class="control-group">
+    <label>Parameter Name</label>
+    <input type="range" id="param" min="..." max="..." step="..." value="..." oninput="updateParam('param', this.value)">
+    <span class="value-display" id="param-value">...</span>
+</div>
+```
+Add as many control-group divs as there are parameters.
+
+**3. Colors (OPTIONAL/VARIABLE)** - Include if the art needs adjustable colors:
+- Add color pickers if users should control palette
+- Skip this section if the art uses fixed colors
+- Skip if the art is monochrome
+
+**4. Actions (FIXED)** - Always include exactly as shown:
+- Regenerate button
+- Reset button
+- Download PNG button
+
+**Requirements**:
+- Seed controls must work (prev/next/random/jump/display)
+- All parameters must have UI controls
+- Regenerate, Reset, Download buttons must work
+- Keep Anthropic branding (UI styling, not art colors)
+
+### USING THE ARTIFACT
+
+The HTML artifact works immediately:
+1. **In claude.ai**: Displayed as an interactive artifact - runs instantly
+2. **As a file**: Save and open in any browser - no server needed
+3. **Sharing**: Send the HTML file - it's completely self-contained
+
+---
+
+## VARIATIONS & EXPLORATION
+
+The artifact includes seed navigation by default (prev/next/random buttons), allowing users to explore variations without creating multiple files. If the user wants specific variations highlighted:
+
+- Include seed presets (buttons for "Variation 1: Seed 42", "Variation 2: Seed 127", etc.)
+- Add a "Gallery Mode" that shows thumbnails of multiple seeds side-by-side
+- All within the same single artifact
+
+This is like creating a series of prints from the same plate - the algorithm is consistent, but each seed reveals different facets of its potential. The interactive nature means users discover their own favorites by exploring the seed space.
+
+---
+
+## THE CREATIVE PROCESS
+
+**User request** → **Algorithmic philosophy** → **Implementation**
+
+Each request is unique. The process involves:
+
+1. **Interpret the user's intent** - What aesthetic is being sought?
+2. **Create an algorithmic philosophy** (4-6 paragraphs) describing the computational approach
+3. **Implement it in code** - Build the algorithm that expresses this philosophy
+4. **Design appropriate parameters** - What should be tunable?
+5. **Build matching UI controls** - Sliders/inputs for those parameters
+
+**The constants**:
+- Anthropic branding (colors, fonts, layout)
+- Seed navigation (always present)
+- Self-contained HTML artifact
+
+**Everything else is variable**:
+- The algorithm itself
+- The parameters
+- The UI controls
+- The visual outcome
+
+To achieve the best results, trust creativity and let the philosophy guide the implementation.
+
+---
+
+## RESOURCES
+
+This skill includes helpful templates and documentation:
+
+- **templates/viewer.html**: REQUIRED STARTING POINT for all HTML artifacts.
+  - This is the foundation - contains the exact structure and Anthropic branding
+  - **Keep unchanged**: Layout structure, sidebar organization, Anthropic colors/fonts, seed controls, action buttons
+  - **Replace**: The p5.js algorithm, parameter definitions, and UI controls in Parameters section
+  - The extensive comments in the file mark exactly what to keep vs replace
+
+- **templates/generator_template.js**: Reference for p5.js best practices and code structure principles.
+  - Shows how to organize parameters, use seeded randomness, structure classes
+  - NOT a pattern menu - use these principles to build unique algorithms
+  - Embed algorithms inline in the HTML artifact (don't create separate .js files)
+
+**Critical reminder**:
+- The **template is the STARTING POINT**, not inspiration
+- The **algorithm is where to create** something unique
+- Don't copy the flow field example - build what the philosophy demands
+- But DO keep the exact UI structure and Anthropic branding from the template

adapters-output/cursor/brand-guidelines.md

@@ -0,0 +1,77 @@
+# Brand Guidelines
+
+## Description
+Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
+
+## When to Use
+Use this skill when the user asks about: Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
+
+## Instructions
+
+# Anthropic Brand Styling
+
+## Overview
+
+To access Anthropic's official brand identity and style resources, use this skill.
+
+**Keywords**: branding, corporate identity, visual identity, post-processing, styling, brand colors, typography, Anthropic brand, visual formatting, visual design
+
+## Brand Guidelines
+
+### Colors
+
+**Main Colors:**
+
+- Dark: `#141413` - Primary text and dark backgrounds
+- Light: `#faf9f5` - Light backgrounds and text on dark
+- Mid Gray: `#b0aea5` - Secondary elements
+- Light Gray: `#e8e6dc` - Subtle backgrounds
+
+**Accent Colors:**
+
+- Orange: `#d97757` - Primary accent
+- Blue: `#6a9bcc` - Secondary accent
+- Green: `#788c5d` - Tertiary accent
+
+### Typography
+
+- **Headings**: Poppins (with Arial fallback)
+- **Body Text**: Lora (with Georgia fallback)
+- **Note**: Fonts should be pre-installed in your environment for best results
+
+## Features
+
+### Smart Font Application
+
+- Applies Poppins font to headings (24pt and larger)
+- Applies Lora font to body text
+- Automatically falls back to Arial/Georgia if custom fonts unavailable
+- Preserves readability across all systems
+
+### Text Styling
+
+- Headings (24pt+): Poppins font
+- Body text: Lora font
+- Smart color selection based on background
+- Preserves text hierarchy and formatting
+
+### Shape and Accent Colors
+
+- Non-text shapes use accent colors
+- Cycles through orange, blue, and green accents
+- Maintains visual interest while staying on-brand
+
+## Technical Details
+
+### Font Management
+
+- Uses system-installed Poppins and Lora fonts when available
+- Provides automatic fallback to Arial (headings) and Georgia (body)
+- No font installation required - works with existing system fonts
+- For best results, pre-install Poppins and Lora fonts in your environment
+
+### Color Application
+
+- Uses RGB color values for precise brand matching
+- Applied via python-pptx's RGBColor class
+- Maintains color fidelity across different systems

adapters-output/cursor/canvas-design.md

@@ -0,0 +1,134 @@
+# Canvas Design
+
+## Description
+Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.
+
+## When to Use
+Use this skill when the user asks about: Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.
+
+## Instructions
+
+These are instructions for creating design philosophies - aesthetic movements that are then EXPRESSED VISUALLY. Output only .md files, .pdf files, and .png files.
+
+Complete this in two steps:
+1. Design Philosophy Creation (.md file)
+2. Express by creating it on a canvas (.pdf file or .png file)
+
+First, undertake this task:
+
+## DESIGN PHILOSOPHY CREATION
+
+To begin, create a VISUAL PHILOSOPHY (not layouts or templates) that will be interpreted through:
+- Form, space, color, composition
+- Images, graphics, shapes, patterns
+- Minimal text as visual accent
+
+### THE CRITICAL UNDERSTANDING
+- What is received: Some subtle input or instructions by the user that should be taken into account, but used as a foundation; it should not constrain creative freedom.
+- What is created: A design philosophy/aesthetic movement.
+- What happens next: Then, the same version receives the philosophy and EXPRESSES IT VISUALLY - creating artifacts that are 90% visual design, 10% essential text.
+
+Consider this approach:
+- Write a manifesto for an art movement
+- The next phase involves making the artwork
+
+The philosophy must emphasize: Visual expression. Spatial communication. Artistic interpretation. Minimal words.
+
+### HOW TO GENERATE A VISUAL PHILOSOPHY
+
+**Name the movement** (1-2 words): "Brutalist Joy" / "Chromatic Silence" / "Metabolist Dreams"
+
+**Articulate the philosophy** (4-6 paragraphs - concise but complete):
+
+To capture the VISUAL essence, express how the philosophy manifests through:
+- Space and form
+- Color and material
+- Scale and rhythm
+- Composition and balance
+- Visual hierarchy
+
+**CRITICAL GUIDELINES:**
+- **Avoid redundancy**: Each design aspect should be mentioned once. Avoid repeating points about color theory, spatial relationships, or typographic principles unless adding new depth.
+- **Emphasize craftsmanship REPEATEDLY**: The philosophy MUST stress multiple times that the final work should appear as though it took countless hours to create, was labored over with care, and comes from someone at the absolute top of their field. This framing is essential - repeat phrases like "meticulously crafted," "the product of deep expertise," "painstaking attention," "master-level execution."
+- **Leave creative space**: Remain specific about the aesthetic direction, but concise enough that the next Claude has room to make interpretive choices also at a extremely high level of craftmanship.
+
+The philosophy must guide the next version to express ideas VISUALLY, not through text. Information lives in design, not paragraphs.
+
+### PHILOSOPHY EXAMPLES
+
+**"Concrete Poetry"**
+Philosophy: Communication through monumental form and bold geometry.
+Visual expression: Massive color blocks, sculptural typography (huge single words, tiny labels), Brutalist spatial divisions, Polish poster energy meets Le Corbusier. Ideas expressed through visual weight and spatial tension, not explanation. Text as rare, powerful gesture - never paragraphs, only essential words integrated into the visual architecture. Every element placed with the precision of a master craftsman.
+
+**"Chromatic Language"**
+Philosophy: Color as the primary information system.
+Visual expression: Geometric precision where color zones create meaning. Typography minimal - small sans-serif labels letting chromatic fields communicate. Think Josef Albers' interaction meets data visualization. Information encoded spatially and chromatically. Words only to anchor what color already shows. The result of painstaking chromatic calibration.
+
+**"Analog Meditation"**
+Philosophy: Quiet visual contemplation through texture and breathing room.
+Visual expression: Paper grain, ink bleeds, vast negative space. Photography and illustration dominate. Typography whispered (small, restrained, serving the visual). Japanese photobook aesthetic. Images breathe across pages. Text appears sparingly - short phrases, never explanatory blocks. Each composition balanced with the care of a meditation practice.
+
+**"Organic Systems"**
+Philosophy: Natural clustering and modular growth patterns.
+Visual expression: Rounded forms, organic arrangements, color from nature through architecture. Information shown through visual diagrams, spatial relationships, iconography. Text only for key labels floating in space. The composition tells the story through expert spatial orchestration.
+
+**"Geometric Silence"**
+Philosophy: Pure order and restraint.
+Visual expression: Grid-based precision, bold photography or stark graphics, dramatic negative space. Typography precise but minimal - small essential text, large quiet zones. Swiss formalism meets Brutalist material honesty. Structure communicates, not words. Every alignment the work of countless refinements.
+
+*These are condensed examples. The actual design philosophy should be 4-6 substantial paragraphs.*
+
+### ESSENTIAL PRINCIPLES
+- **VISUAL PHILOSOPHY**: Create an aesthetic worldview to be expressed through design
+- **MINIMAL TEXT**: Always emphasize that text is sparse, essential-only, integrated as visual element - never lengthy
+- **SPATIAL EXPRESSION**: Ideas communicate through space, form, color, composition - not paragraphs
+- **ARTISTIC FREEDOM**: The next Claude interprets the philosophy visually - provide creative room
+- **PURE DESIGN**: This is about making ART OBJECTS, not documents with decoration
+- **EXPERT CRAFTSMANSHIP**: Repeatedly emphasize the final work must look meticulously crafted, labored over with care, the product of countless hours by someone at the top of their field
+
+**The design philosophy should be 4-6 paragraphs long.** Fill it with poetic design philosophy that brings together the core vision. Avoid repeating the same points. Keep the design philosophy generic without mentioning the intention of the art, as if it can be used wherever. Output the design philosophy as a .md file.
+
+---
+
+## DEDUCING THE SUBTLE REFERENCE
+
+**CRITICAL STEP**: Before creating the canvas, identify the subtle conceptual thread from the original request.
+
+**THE ESSENTIAL PRINCIPLE**:
+The topic is a **subtle, niche reference embedded within the art itself** - not always literal, always sophisticated. Someone familiar with the subject should feel it intuitively, while others simply experience a masterful abstract composition. The design philosophy provides the aesthetic language. The deduced topic provides the soul - the quiet conceptual DNA woven invisibly into form, color, and composition.
+
+This is **VERY IMPORTANT**: The reference must be refined so it enhances the work's depth without announcing itself. Think like a jazz musician quoting another song - only those who know will catch it, but everyone appreciates the music.
+
+---
+
+## CANVAS CREATION
+
+With both the philosophy and the conceptual framework established, express it on a canvas. Take a moment to gather thoughts and clear the mind. Use the design philosophy created and the instructions below to craft a masterpiece, embodying all aspects of the philosophy with expert craftsmanship.
+
+**IMPORTANT**: For any type of content, even if the user requests something for a movie/game/book, the approach should still be sophisticated. Never lose sight of the idea that this should be art, not something that's cartoony or amateur.
+
+To create museum or magazine quality work, use the design philosophy as the foundation. Create one single page, highly visual, design-forward PDF or PNG output (unless asked for more pages). Generally use repeating patterns and perfect shapes. Treat the abstract philosophical design as if it were a scientific bible, borrowing the visual language of systematic observation—dense accumulation of marks, repeated elements, or layered patterns that build meaning through patient repetition and reward sustained viewing. Add sparse, clinical typography and systematic reference markers that suggest this could be a diagram from an imaginary discipline, treating the invisible subject with the same reverence typically reserved for documenting observable phenomena. Anchor the piece with simple phrase(s) or details positioned subtly, using a limited color palette that feels intentional and cohesive. Embrace the paradox of using analytical visual language to express ideas about human experience: the result should feel like an artifact that proves something ephemeral can be studied, mapped, and understood through careful attention. This is true art. 
+
+**Text as a contextual element**: Text is always minimal and visual-first, but let context guide whether that means whisper-quiet labels or bold typographic gestures. A punk venue poster might have larger, more aggressive type than a minimalist ceramics studio identity. Most of the time, font should be thin. All use of fonts must be design-forward and prioritize visual communication. Regardless of text scale, nothing falls off the page and nothing overlaps. Every element must be contained within the canvas boundaries with proper margins. Check carefully that all text, graphics, and visual elements have breathing room and clear separation. This is non-negotiable for professional execution. **IMPORTANT: Use different fonts if writing text. Search the `./canvas-fonts` directory. Regardless of approach, sophistication is non-negotiable.**
+
+Download and use whatever fonts are needed to make this a reality. Get creative by making the typography actually part of the art itself -- if the art is abstract, bring the font onto the canvas, not typeset digitally.
+
+To push boundaries, follow design instinct/intuition while using the philosophy as a guiding principle. Embrace ultimate design freedom and choice. Push aesthetics and design to the frontier. 
+
+**CRITICAL**: To achieve human-crafted quality (not AI-generated), create work that looks like it took countless hours. Make it appear as though someone at the absolute top of their field labored over every detail with painstaking care. Ensure the composition, spacing, color choices, typography - everything screams expert-level craftsmanship. Double-check that nothing overlaps, formatting is flawless, every detail perfect. Create something that could be shown to people to prove expertise and rank as undeniably impressive.
+
+Output the final result as a single, downloadable .pdf or .png file, alongside the design philosophy used as a .md file.
+
+---
+
+## FINAL STEP
+
+**IMPORTANT**: The user ALREADY said "It isn't perfect enough. It must be pristine, a masterpiece if craftsmanship, as if it were about to be displayed in a museum."
+
+**CRITICAL**: To refine the work, avoid adding more graphics; instead refine what has been created and make it extremely crisp, respecting the design philosophy and the principles of minimalism entirely. Rather than adding a fun filter or refactoring a font, consider how to make the existing composition more cohesive with the art. If the instinct is to call a new function or draw a new shape, STOP and instead ask: "How can I make what's already here more of a piece of art?"
+
+Take a second pass. Go back to the code and refine/polish further to make this a philosophically designed masterpiece.
+
+## MULTI-PAGE OPTION
+
+To create additional pages when requested, create more creative pages along the same lines as the design philosophy but distinctly different as well. Bundle those pages in the same .pdf or many .pngs. Treat the first page as just a single page in a whole coffee table book waiting to be filled. Make the next pages unique twists and memories of the original. Have them almost tell a story in a very tasteful way. Exercise full creative freedom.

adapters-output/cursor/code-generator.md

@@ -0,0 +1,94 @@
+# Code Generator
+
+## Description
+帮助生成高质量的代码，包括函数、类、模块和完整项目。支持多种编程语言，遵循最佳实践和设计模式。适用于快速开发、代码示例生成或教学演示。
+
+## When to Use
+Use this skill when the user asks about: 帮助生成高质量的代码，包括函数、类、模块和完整项目。支持多种编程语言，遵循最佳实践和设计模式。适用于快速开发、代码示例生成或教学演示。
+
+## Instructions
+
+# 代码生成技能
+
+## 概述
+
+本技能帮助您生成高质量的代码，支持多种编程语言，遵循最佳实践和设计模式。
+
+**关键词**: 代码生成、编程、函数、类、模块、项目开发、代码示例
+
+## 核心功能
+
+### 1. 函数和类生成
+
+- 生成符合规范的函数和类
+- 添加完整的文档注释
+- 实现错误处理和边界检查
+- 遵循语言特定的最佳实践
+
+### 2. 模块和包开发
+
+- 创建结构化的模块和包
+- 设计清晰的 API 接口
+- 实现模块间的依赖管理
+- 创建配置文件和初始化代码
+
+### 3. 项目脚手架
+
+- 生成完整的项目结构
+- 创建配置文件（package.json, requirements.txt 等）
+- 设置构建和测试环境
+- 添加 README 和文档
+
+### 4. 代码优化和重构
+
+- 优化代码性能和可读性
+- 应用设计模式和最佳实践
+- 重构代码结构
+- 添加单元测试
+
+## 使用指南
+
+### 代码生成原则
+
+1. **清晰性**: 代码应清晰易懂，命名规范
+2. **可维护性**: 结构良好，易于修改和扩展
+3. **健壮性**: 包含错误处理和边界检查
+4. **文档化**: 提供完整的注释和文档
+5. **测试性**: 代码应易于测试
+
+### 支持的编程语言
+
+- Python
+- JavaScript/TypeScript
+- Java
+- Go
+- Rust
+- 其他常见编程语言
+
+### 代码结构要求
+
+- **导入部分**: 清晰的导入语句
+- **文档字符串**: 函数和类的文档
+- **实现代码**: 核心逻辑实现
+- **测试代码**: 单元测试（如需要）
+- **示例代码**: 使用示例（如需要）
+
+## 输出格式
+
+生成的代码应包含：
+
+- **代码文件**: 完整的源代码文件
+- **文档注释**: 函数、类、模块的文档
+- **使用示例**: 代码使用示例
+- **依赖说明**: 所需的依赖和版本
+- **测试代码**: 相关的测试用例
+
+## 最佳实践
+
+- 遵循语言的编码规范和风格指南
+- 使用有意义的变量和函数名
+- 添加类型提示（如适用）
+- 实现适当的错误处理
+- 编写清晰的文档注释
+- 考虑性能和可扩展性
+- 遵循 SOLID 原则和设计模式

adapters-output/cursor/course-designer.md

@@ -0,0 +1,91 @@
+# Course Designer
+
+## Description
+帮助设计和规划课程内容，包括课程大纲、学习目标、教学计划和评估方案。适用于教育工作者、培训师或需要创建结构化学习内容的场景。
+
+## When to Use
+Use this skill when the user asks about: 帮助设计和规划课程内容，包括课程大纲、学习目标、教学计划和评估方案。适用于教育工作者、培训师或需要创建结构化学习内容的场景。
+
+## Instructions
+
+# 课程设计技能
+
+## 概述
+
+本技能帮助您创建结构化的课程内容，包括课程大纲、学习目标、教学计划和评估方案。
+
+**关键词**: 课程设计、教学大纲、学习目标、教学计划、课程规划、教育设计
+
+## 核心功能
+
+### 1. 课程大纲设计
+
+- 分析学习需求和目标受众
+- 设计课程结构和模块划分
+- 确定课程时长和进度安排
+- 规划知识点的递进关系
+
+### 2. 学习目标制定
+
+- 使用 Bloom 分类法制定认知目标
+- 设计可测量的学习成果
+- 确保目标与评估方式对齐
+- 区分不同层次的学习目标（记忆、理解、应用、分析、评价、创造）
+
+### 3. 教学计划编写
+
+- 设计每节课的教学流程
+- 规划教学活动和互动环节
+- 准备教学资源和材料清单
+- 安排实践练习和作业
+
+### 4. 评估方案设计
+
+- 设计形成性评估（过程评估）
+- 设计总结性评估（最终评估）
+- 创建评估标准和评分 rubric
+- 规划多种评估方式（测验、项目、报告等）
+
+## 使用指南
+
+### 课程设计流程
+
+1. **需求分析**
+   - 明确目标受众和学习需求
+   - 确定课程目标和预期成果
+   - 分析现有资源和约束条件
+
+2. **内容规划**
+   - 划分课程模块和单元
+   - 确定每个模块的核心知识点
+   - 规划知识点的学习顺序
+
+3. **活动设计**
+   - 为每个知识点设计教学活动
+   - 规划实践练习和项目
+   - 设计互动和讨论环节
+
+4. **评估设计**
+   - 设计评估方式和标准
+   - 创建评估工具和 rubric
+   - 规划评估时间点
+
+## 输出格式
+
+课程设计应包含以下部分：
+
+- **课程基本信息**: 课程名称、目标受众、总时长
+- **课程目标**: 总体目标和具体学习目标
+- **课程大纲**: 模块划分和内容概览
+- **详细教学计划**: 每节课的教学安排
+- **评估方案**: 评估方式和标准
+- **资源清单**: 所需的教学资源
+
+## 最佳实践
+
+- 确保学习目标清晰、可测量
+- 保持内容递进，由浅入深
+- 平衡理论学习和实践应用
+- 设计多样化的教学活动
+- 评估方式应与学习目标对齐
+- 考虑不同学习风格和需求

adapters-output/cursor/doc-coauthoring.md

@@ -0,0 +1,380 @@
+# Doc Coauthoring
+
+## Description
+Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.
+
+## When to Use
+Use this skill when the user asks about: Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.
+
+## Instructions
+
+# Doc Co-Authoring Workflow
+
+This skill provides a structured workflow for guiding users through collaborative document creation. Act as an active guide, walking users through three stages: Context Gathering, Refinement & Structure, and Reader Testing.
+
+## When to Offer This Workflow
+
+**Trigger conditions:**
+- User mentions writing documentation: "write a doc", "draft a proposal", "create a spec", "write up"
+- User mentions specific doc types: "PRD", "design doc", "decision doc", "RFC"
+- User seems to be starting a substantial writing task
+
+**Initial offer:**
+Offer the user a structured workflow for co-authoring the document. Explain the three stages:
+
+1. **Context Gathering**: User provides all relevant context while Claude asks clarifying questions
+2. **Refinement & Structure**: Iteratively build each section through brainstorming and editing
+3. **Reader Testing**: Test the doc with a fresh Claude (no context) to catch blind spots before others read it
+
+Explain that this approach helps ensure the doc works well when others read it (including when they paste it into Claude). Ask if they want to try this workflow or prefer to work freeform.
+
+If user declines, work freeform. If user accepts, proceed to Stage 1.
+
+## Stage 1: Context Gathering
+
+**Goal:** Close the gap between what the user knows and what Claude knows, enabling smart guidance later.
+
+### Initial Questions
+
+Start by asking the user for meta-context about the document:
+
+1. What type of document is this? (e.g., technical spec, decision doc, proposal)
+2. Who's the primary audience?
+3. What's the desired impact when someone reads this?
+4. Is there a template or specific format to follow?
+5. Any other constraints or context to know?
+
+Inform them they can answer in shorthand or dump information however works best for them.
+
+**If user provides a template or mentions a doc type:**
+- Ask if they have a template document to share
+- If they provide a link to a shared document, use the appropriate integration to fetch it
+- If they provide a file, read it
+
+**If user mentions editing an existing shared document:**
+- Use the appropriate integration to read the current state
+- Check for images without alt-text
+- If images exist without alt-text, explain that when others use Claude to understand the doc, Claude won't be able to see them. Ask if they want alt-text generated. If so, request they paste each image into chat for descriptive alt-text generation.
+
+### Info Dumping
+
+Once initial questions are answered, encourage the user to dump all the context they have. Request information such as:
+- Background on the project/problem
+- Related team discussions or shared documents
+- Why alternative solutions aren't being used
+- Organizational context (team dynamics, past incidents, politics)
+- Timeline pressures or constraints
+- Technical architecture or dependencies
+- Stakeholder concerns
+
+Advise them not to worry about organizing it - just get it all out. Offer multiple ways to provide context:
+- Info dump stream-of-consciousness
+- Point to team channels or threads to read
+- Link to shared documents
+
+**If integrations are available** (e.g., Slack, Teams, Google Drive, SharePoint, or other MCP servers), mention that these can be used to pull in context directly.
+
+**If no integrations are detected and in Claude.ai or Claude app:** Suggest they can enable connectors in their Claude settings to allow pulling context from messaging apps and document storage directly.
+
+Inform them clarifying questions will be asked once they've done their initial dump.
+
+**During context gathering:**
+
+- If user mentions team channels or shared documents:
+  - If integrations available: Inform them the content will be read now, then use the appropriate integration
+  - If integrations not available: Explain lack of access. Suggest they enable connectors in Claude settings, or paste the relevant content directly.
+
+- If user mentions entities/projects that are unknown:
+  - Ask if connected tools should be searched to learn more
+  - Wait for user confirmation before searching
+
+- As user provides context, track what's being learned and what's still unclear
+
+**Asking clarifying questions:**
+
+When user signals they've done their initial dump (or after substantial context provided), ask clarifying questions to ensure understanding:
+
+Generate 5-10 numbered questions based on gaps in the context.
+
+Inform them they can use shorthand to answer (e.g., "1: yes, 2: see #channel, 3: no because backwards compat"), link to more docs, point to channels to read, or just keep info-dumping. Whatever's most efficient for them.
+
+**Exit condition:**
+Sufficient context has been gathered when questions show understanding - when edge cases and trade-offs can be asked about without needing basics explained.
+
+**Transition:**
+Ask if there's any more context they want to provide at this stage, or if it's time to move on to drafting the document.
+
+If user wants to add more, let them. When ready, proceed to Stage 2.
+
+## Stage 2: Refinement & Structure
+
+**Goal:** Build the document section by section through brainstorming, curation, and iterative refinement.
+
+**Instructions to user:**
+Explain that the document will be built section by section. For each section:
+1. Clarifying questions will be asked about what to include
+2. 5-20 options will be brainstormed
+3. User will indicate what to keep/remove/combine
+4. The section will be drafted
+5. It will be refined through surgical edits
+
+Start with whichever section has the most unknowns (usually the core decision/proposal), then work through the rest.
+
+**Section ordering:**
+
+If the document structure is clear:
+Ask which section they'd like to start with.
+
+Suggest starting with whichever section has the most unknowns. For decision docs, that's usually the core proposal. For specs, it's typically the technical approach. Summary sections are best left for last.
+
+If user doesn't know what sections they need:
+Based on the type of document and template, suggest 3-5 sections appropriate for the doc type.
+
+Ask if this structure works, or if they want to adjust it.
+
+**Once structure is agreed:**
+
+Create the initial document structure with placeholder text for all sections.
+
+**If access to artifacts is available:**
+Use `create_file` to create an artifact. This gives both Claude and the user a scaffold to work from.
+
+Inform them that the initial structure with placeholders for all sections will be created.
+
+Create artifact with all section headers and brief placeholder text like "[To be written]" or "[Content here]".
+
+Provide the scaffold link and indicate it's time to fill in each section.
+
+**If no access to artifacts:**
+Create a markdown file in the working directory. Name it appropriately (e.g., `decision-doc.md`, `technical-spec.md`).
+
+Inform them that the initial structure with placeholders for all sections will be created.
+
+Create file with all section headers and placeholder text.
+
+Confirm the filename has been created and indicate it's time to fill in each section.
+
+**For each section:**
+
+### Step 1: Clarifying Questions
+
+Announce work will begin on the [SECTION NAME] section. Ask 5-10 clarifying questions about what should be included:
+
+Generate 5-10 specific questions based on context and section purpose.
+
+Inform them they can answer in shorthand or just indicate what's important to cover.
+
+### Step 2: Brainstorming
+
+For the [SECTION NAME] section, brainstorm [5-20] things that might be included, depending on the section's complexity. Look for:
+- Context shared that might have been forgotten
+- Angles or considerations not yet mentioned
+
+Generate 5-20 numbered options based on section complexity. At the end, offer to brainstorm more if they want additional options.
+
+### Step 3: Curation
+
+Ask which points should be kept, removed, or combined. Request brief justifications to help learn priorities for the next sections.
+
+Provide examples:
+- "Keep 1,4,7,9"
+- "Remove 3 (duplicates 1)"
+- "Remove 6 (audience already knows this)"
+- "Combine 11 and 12"
+
+**If user gives freeform feedback** (e.g., "looks good" or "I like most of it but...") instead of numbered selections, extract their preferences and proceed. Parse what they want kept/removed/changed and apply it.
+
+### Step 4: Gap Check
+
+Based on what they've selected, ask if there's anything important missing for the [SECTION NAME] section.
+
+### Step 5: Drafting
+
+Use `str_replace` to replace the placeholder text for this section with the actual drafted content.
+
+Announce the [SECTION NAME] section will be drafted now based on what they've selected.
+
+**If using artifacts:**
+After drafting, provide a link to the artifact.
+
+Ask them to read through it and indicate what to change. Note that being specific helps learning for the next sections.
+
+**If using a file (no artifacts):**
+After drafting, confirm completion.
+
+Inform them the [SECTION NAME] section has been drafted in [filename]. Ask them to read through it and indicate what to change. Note that being specific helps learning for the next sections.
+
+**Key instruction for user (include when drafting the first section):**
+Provide a note: Instead of editing the doc directly, ask them to indicate what to change. This helps learning of their style for future sections. For example: "Remove the X bullet - already covered by Y" or "Make the third paragraph more concise".
+
+### Step 6: Iterative Refinement
+
+As user provides feedback:
+- Use `str_replace` to make edits (never reprint the whole doc)
+- **If using artifacts:** Provide link to artifact after each edit
+- **If using files:** Just confirm edits are complete
+- If user edits doc directly and asks to read it: mentally note the changes they made and keep them in mind for future sections (this shows their preferences)
+
+**Continue iterating** until user is satisfied with the section.
+
+### Quality Checking
+
+After 3 consecutive iterations with no substantial changes, ask if anything can be removed without losing important information.
+
+When section is done, confirm [SECTION NAME] is complete. Ask if ready to move to the next section.
+
+**Repeat for all sections.**
+
+### Near Completion
+
+As approaching completion (80%+ of sections done), announce intention to re-read the entire document and check for:
+- Flow and consistency across sections
+- Redundancy or contradictions
+- Anything that feels like "slop" or generic filler
+- Whether every sentence carries weight
+
+Read entire document and provide feedback.
+
+**When all sections are drafted and refined:**
+Announce all sections are drafted. Indicate intention to review the complete document one more time.
+
+Review for overall coherence, flow, completeness.
+
+Provide any final suggestions.
+
+Ask if ready to move to Reader Testing, or if they want to refine anything else.
+
+## Stage 3: Reader Testing
+
+**Goal:** Test the document with a fresh Claude (no context bleed) to verify it works for readers.
+
+**Instructions to user:**
+Explain that testing will now occur to see if the document actually works for readers. This catches blind spots - things that make sense to the authors but might confuse others.
+
+### Testing Approach
+
+**If access to sub-agents is available (e.g., in Claude Code):**
+
+Perform the testing directly without user involvement.
+
+### Step 1: Predict Reader Questions
+
+Announce intention to predict what questions readers might ask when trying to discover this document.
+
+Generate 5-10 questions that readers would realistically ask.
+
+### Step 2: Test with Sub-Agent
+
+Announce that these questions will be tested with a fresh Claude instance (no context from this conversation).
+
+For each question, invoke a sub-agent with just the document content and the question.
+
+Summarize what Reader Claude got right/wrong for each question.
+
+### Step 3: Run Additional Checks
+
+Announce additional checks will be performed.
+
+Invoke sub-agent to check for ambiguity, false assumptions, contradictions.
+
+Summarize any issues found.
+
+### Step 4: Report and Fix
+
+If issues found:
+Report that Reader Claude struggled with specific issues.
+
+List the specific issues.
+
+Indicate intention to fix these gaps.
+
+Loop back to refinement for problematic sections.
+
+---
+
+**If no access to sub-agents (e.g., claude.ai web interface):**
+
+The user will need to do the testing manually.
+
+### Step 1: Predict Reader Questions
+
+Ask what questions people might ask when trying to discover this document. What would they type into Claude.ai?
+
+Generate 5-10 questions that readers would realistically ask.
+
+### Step 2: Setup Testing
+
+Provide testing instructions:
+1. Open a fresh Claude conversation: https://claude.ai
+2. Paste or share the document content (if using a shared doc platform with connectors enabled, provide the link)
+3. Ask Reader Claude the generated questions
+
+For each question, instruct Reader Claude to provide:
+- The answer
+- Whether anything was ambiguous or unclear
+- What knowledge/context the doc assumes is already known
+
+Check if Reader Claude gives correct answers or misinterprets anything.
+
+### Step 3: Additional Checks
+
+Also ask Reader Claude:
+- "What in this doc might be ambiguous or unclear to readers?"
+- "What knowledge or context does this doc assume readers already have?"
+- "Are there any internal contradictions or inconsistencies?"
+
+### Step 4: Iterate Based on Results
+
+Ask what Reader Claude got wrong or struggled with. Indicate intention to fix those gaps.
+
+Loop back to refinement for any problematic sections.
+
+---
+
+### Exit Condition (Both Approaches)
+
+When Reader Claude consistently answers questions correctly and doesn't surface new gaps or ambiguities, the doc is ready.
+
+## Final Review
+
+When Reader Testing passes:
+Announce the doc has passed Reader Claude testing. Before completion:
+
+1. Recommend they do a final read-through themselves - they own this document and are responsible for its quality
+2. Suggest double-checking any facts, links, or technical details
+3. Ask them to verify it achieves the impact they wanted
+
+Ask if they want one more review, or if the work is done.
+
+**If user wants final review, provide it. Otherwise:**
+Announce document completion. Provide a few final tips:
+- Consider linking this conversation in an appendix so readers can see how the doc was developed
+- Use appendices to provide depth without bloating the main doc
+- Update the doc as feedback is received from real readers
+
+## Tips for Effective Guidance
+
+**Tone:**
+- Be direct and procedural
+- Explain rationale briefly when it affects user behavior
+- Don't try to "sell" the approach - just execute it
+
+**Handling Deviations:**
+- If user wants to skip a stage: Ask if they want to skip this and write freeform
+- If user seems frustrated: Acknowledge this is taking longer than expected. Suggest ways to move faster
+- Always give user agency to adjust the process
+
+**Context Management:**
+- Throughout, if context is missing on something mentioned, proactively ask
+- Don't let gaps accumulate - address them as they come up
+
+**Artifact Management:**
+- Use `create_file` for drafting full sections
+- Use `str_replace` for all edits
+- Provide artifact link after every change
+- Never use artifacts for brainstorming lists - that's just conversation
+
+**Quality over Speed:**
+- Don't rush through stages
+- Each iteration should make meaningful improvements
+- The goal is a document that actually works for readers

adapters-output/cursor/documentation-builder.md

@@ -0,0 +1,93 @@
+# Documentation Builder
+
+## Description
+帮助生成技术文档，包括 API 文档、用户手册、开发指南、README 等。支持多种文档格式，确保文档清晰、完整、易于理解。
+
+## When to Use
+Use this skill when the user asks about: 帮助生成技术文档，包括 API 文档、用户手册、开发指南、README 等。支持多种文档格式，确保文档清晰、完整、易于理解。
+
+## Instructions
+
+# 文档构建技能
+
+## 概述
+
+本技能帮助您生成各种技术文档，包括 API 文档、用户手册、开发指南等。
+
+**关键词**: 文档编写、API 文档、用户手册、开发指南、技术文档、README
+
+## 核心功能
+
+### 1. API 文档生成
+
+- 生成 RESTful API 文档
+- 描述 API 端点、参数和响应
+- 提供请求和响应示例
+- 创建交互式 API 文档（如 Swagger/OpenAPI）
+
+### 2. 用户手册编写
+
+- 编写用户使用指南
+- 创建快速入门教程
+- 提供常见问题解答（FAQ）
+- 设计操作步骤和截图
+
+### 3. 开发指南创建
+
+- 编写开发环境搭建指南
+- 创建代码贡献指南
+- 设计架构和设计文档
+- 提供开发最佳实践
+
+### 4. README 和项目文档
+
+- 生成项目 README
+- 创建安装和使用说明
+- 编写变更日志（CHANGELOG）
+- 设计项目结构说明
+
+## 使用指南
+
+### 文档编写原则
+
+1. **清晰性**: 文档应清晰易懂，避免歧义
+2. **完整性**: 覆盖所有重要功能和场景
+3. **准确性**: 确保文档与代码一致
+4. **实用性**: 提供实际可用的示例
+5. **可维护性**: 文档应易于更新和维护
+
+### 文档结构
+
+- **概述**: 项目或功能的概述
+- **快速开始**: 快速上手指南
+- **详细说明**: 详细的功能说明
+- **API 参考**: API 接口文档（如适用）
+- **示例**: 使用示例和代码示例
+- **常见问题**: FAQ 和故障排除
+
+### 文档格式
+
+- Markdown（.md）
+- reStructuredText（.rst）
+- HTML
+- PDF（如需要）
+
+## 输出格式
+
+文档应包含：
+
+- **文档文件**: 完整的文档内容
+- **目录结构**: 清晰的章节和目录
+- **代码示例**: 实际可运行的代码示例
+- **图表和截图**: 可视化说明（如需要）
+- **链接和引用**: 相关资源的链接
+
+## 最佳实践
+
+- 使用清晰的标题和章节结构
+- 提供实际可用的代码示例
+- 保持文档与代码同步更新
+- 使用图表和截图辅助说明
+- 编写易于搜索的文档
+- 考虑不同水平的读者
+- 定期审查和更新文档

adapters-output/cursor/docx.md

@@ -0,0 +1,201 @@
+# Docx
+
+## Description
+Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks
+
+## When to Use
+Use this skill when the user asks about: Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks
+
+## Instructions
+
+# DOCX creation, editing, and analysis
+
+## Overview
+
+A user may ask you to create, edit, or analyze the contents of a .docx file. A .docx file is essentially a ZIP archive containing XML files and other resources that you can read or edit. You have different tools and workflows available for different tasks.
+
+## Workflow Decision Tree
+
+### Reading/Analyzing Content
+Use "Text extraction" or "Raw XML access" sections below
+
+### Creating New Document
+Use "Creating a new Word document" workflow
+
+### Editing Existing Document
+- **Your own document + simple changes**
+  Use "Basic OOXML editing" workflow
+
+- **Someone else's document**
+  Use **"Redlining workflow"** (recommended default)
+
+- **Legal, academic, business, or government docs**
+  Use **"Redlining workflow"** (required)
+
+## Reading and analyzing content
+
+### Text extraction
+If you just need to read the text contents of a document, you should convert the document to markdown using pandoc. Pandoc provides excellent support for preserving document structure and can show tracked changes:
+
+```bash
+# Convert document to markdown with tracked changes
+pandoc --track-changes=all path-to-file.docx -o output.md
+# Options: --track-changes=accept/reject/all
+```
+
+### Raw XML access
+You need raw XML access for: comments, complex formatting, document structure, embedded media, and metadata. For any of these features, you'll need to unpack a document and read its raw XML contents.
+
+#### Unpacking a file
+`python ooxml/scripts/unpack.py <office_file> <output_directory>`
+
+#### Key file structures
+* `word/document.xml` - Main document contents
+* `word/comments.xml` - Comments referenced in document.xml
+* `word/media/` - Embedded images and media files
+* Tracked changes use `<w:ins>` (insertions) and `<w:del>` (deletions) tags
+
+## Creating a new Word document
+
+When creating a new Word document from scratch, use **docx-js**, which allows you to create Word documents using JavaScript/TypeScript.
+
+### Workflow
+1. **MANDATORY - READ ENTIRE FILE**: Read [`docx-js.md`](docx-js.md) (~500 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for detailed syntax, critical formatting rules, and best practices before proceeding with document creation.
+2. Create a JavaScript/TypeScript file using Document, Paragraph, TextRun components (You can assume all dependencies are installed, but if not, refer to the dependencies section below)
+3. Export as .docx using Packer.toBuffer()
+
+## Editing an existing Word document
+
+When editing an existing Word document, use the **Document library** (a Python library for OOXML manipulation). The library automatically handles infrastructure setup and provides methods for document manipulation. For complex scenarios, you can access the underlying DOM directly through the library.
+
+### Workflow
+1. **MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for the Document library API and XML patterns for directly editing document files.
+2. Unpack the document: `python ooxml/scripts/unpack.py <office_file> <output_directory>`
+3. Create and run a Python script using the Document library (see "Document Library" section in ooxml.md)
+4. Pack the final document: `python ooxml/scripts/pack.py <input_directory> <office_file>`
+
+The Document library provides both high-level methods for common operations and direct DOM access for complex scenarios.
+
+## Redlining workflow for document review
+
+This workflow allows you to plan comprehensive tracked changes using markdown before implementing them in OOXML. **CRITICAL**: For complete tracked changes, you must implement ALL changes systematically.
+
+**Batching Strategy**: Group related changes into batches of 3-10 changes. This makes debugging manageable while maintaining efficiency. Test each batch before moving to the next.
+
+**Principle: Minimal, Precise Edits**
+When implementing tracked changes, only mark text that actually changes. Repeating unchanged text makes edits harder to review and appears unprofessional. Break replacements into: [unchanged text] + [deletion] + [insertion] + [unchanged text]. Preserve the original run's RSID for unchanged text by extracting the `<w:r>` element from the original and reusing it.
+
+Example - Changing "30 days" to "60 days" in a sentence:
+```python
+# BAD - Replaces entire sentence
+'<w:del><w:r><w:delText>The term is 30 days.</w:delText></w:r></w:del><w:ins><w:r><w:t>The term is 60 days.</w:t></w:r></w:ins>'
+
+# GOOD - Only marks what changed, preserves original <w:r> for unchanged text
+'<w:r w:rsidR="00AB12CD"><w:t>The term is </w:t></w:r><w:del><w:r><w:delText>30</w:delText></w:r></w:del><w:ins><w:r><w:t>60</w:t></w:r></w:ins><w:r w:rsidR="00AB12CD"><w:t> days.</w:t></w:r>'
+```
+
+### Tracked changes workflow
+
+1. **Get markdown representation**: Convert document to markdown with tracked changes preserved:
+   ```bash
+   pandoc --track-changes=all path-to-file.docx -o current.md
+   ```
+
+2. **Identify and group changes**: Review the document and identify ALL changes needed, organizing them into logical batches:
+
+   **Location methods** (for finding changes in XML):
+   - Section/heading numbers (e.g., "Section 3.2", "Article IV")
+   - Paragraph identifiers if numbered
+   - Grep patterns with unique surrounding text
+   - Document structure (e.g., "first paragraph", "signature block")
+   - **DO NOT use markdown line numbers** - they don't map to XML structure
+
+   **Batch organization** (group 3-10 related changes per batch):
+   - By section: "Batch 1: Section 2 amendments", "Batch 2: Section 5 updates"
+   - By type: "Batch 1: Date corrections", "Batch 2: Party name changes"
+   - By complexity: Start with simple text replacements, then tackle complex structural changes
+   - Sequential: "Batch 1: Pages 1-3", "Batch 2: Pages 4-6"
+
+3. **Read documentation and unpack**:
+   - **MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Pay special attention to the "Document Library" and "Tracked Change Patterns" sections.
+   - **Unpack the document**: `python ooxml/scripts/unpack.py <file.docx> <dir>`
+   - **Note the suggested RSID**: The unpack script will suggest an RSID to use for your tracked changes. Copy this RSID for use in step 4b.
+
+4. **Implement changes in batches**: Group changes logically (by section, by type, or by proximity) and implement them together in a single script. This approach:
+   - Makes debugging easier (smaller batch = easier to isolate errors)
+   - Allows incremental progress
+   - Maintains efficiency (batch size of 3-10 changes works well)
+
+   **Suggested batch groupings:**
+   - By document section (e.g., "Section 3 changes", "Definitions", "Termination clause")
+   - By change type (e.g., "Date changes", "Party name updates", "Legal term replacements")
+   - By proximity (e.g., "Changes on pages 1-3", "Changes in first half of document")
+
+   For each batch of related changes:
+
+   **a. Map text to XML**: Grep for text in `word/document.xml` to verify how text is split across `<w:r>` elements.
+
+   **b. Create and run script**: Use `get_node` to find nodes, implement changes, then `doc.save()`. See **"Document Library"** section in ooxml.md for patterns.
+
+   **Note**: Always grep `word/document.xml` immediately before writing a script to get current line numbers and verify text content. Line numbers change after each script run.
+
+5. **Pack the document**: After all batches are complete, convert the unpacked directory back to .docx:
+   ```bash
+   python ooxml/scripts/pack.py unpacked reviewed-document.docx
+   ```
+
+6. **Final verification**: Do a comprehensive check of the complete document:
+   - Convert final document to markdown:
+     ```bash
+     pandoc --track-changes=all reviewed-document.docx -o verification.md
+     ```
+   - Verify ALL changes were applied correctly:
+     ```bash
+     grep "original phrase" verification.md  # Should NOT find it
+     grep "replacement phrase" verification.md  # Should find it
+     ```
+   - Check that no unintended changes were introduced
+
+
+## Converting Documents to Images
+
+To visually analyze Word documents, convert them to images using a two-step process:
+
+1. **Convert DOCX to PDF**:
+   ```bash
+   soffice --headless --convert-to pdf document.docx
+   ```
+
+2. **Convert PDF pages to JPEG images**:
+   ```bash
+   pdftoppm -jpeg -r 150 document.pdf page
+   ```
+   This creates files like `page-1.jpg`, `page-2.jpg`, etc.
+
+Options:
+- `-r 150`: Sets resolution to 150 DPI (adjust for quality/size balance)
+- `-jpeg`: Output JPEG format (use `-png` for PNG if preferred)
+- `-f N`: First page to convert (e.g., `-f 2` starts from page 2)
+- `-l N`: Last page to convert (e.g., `-l 5` stops at page 5)
+- `page`: Prefix for output files
+
+Example for specific range:
+```bash
+pdftoppm -jpeg -r 150 -f 2 -l 5 document.pdf page  # Converts only pages 2-5
+```
+
+## Code Style Guidelines
+**IMPORTANT**: When generating code for DOCX operations:
+- Write concise code
+- Avoid verbose variable names and redundant operations
+- Avoid unnecessary print statements
+
+## Dependencies
+
+Required dependencies (install if not available):
+
+- **pandoc**: `sudo apt-get install pandoc` (for text extraction)
+- **docx**: `npm install -g docx` (for creating new documents)
+- **LibreOffice**: `sudo apt-get install libreoffice` (for PDF conversion)
+- **Poppler**: `sudo apt-get install poppler-utils` (for pdftoppm to convert PDF to images)
+- **defusedxml**: `pip install defusedxml` (for secure XML parsing)

adapters-output/cursor/frontend-design.md

@@ -0,0 +1,46 @@
+# Frontend Design
+
+## Description
+Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.
+
+## When to Use
+Use this skill when the user asks about: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.
+
+## Instructions
+
+This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.
+
+The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.
+
+## Design Thinking
+
+Before coding, understand the context and commit to a BOLD aesthetic direction:
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
+- **Constraints**: Technical requirements (framework, performance, accessibility).
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.
+
+Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
+
+## Frontend Aesthetics Guidelines
+
+Focus on:
+- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
+- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
+- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
+- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
+- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.
+
+NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.
+
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.
+
+**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.
+
+Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.

adapters-output/cursor/internal-comms.md

@@ -0,0 +1,36 @@
+# Internal Comms
+
+## Description
+A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).
+
+## When to Use
+Use this skill when the user asks about: A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).
+
+## Instructions
+
+## When to use this skill
+To write internal communications, use this skill for:
+- 3P updates (Progress, Plans, Problems)
+- Company newsletters
+- FAQ responses
+- Status reports
+- Leadership updates
+- Project updates
+- Incident reports
+
+## How to use this skill
+
+To write any internal communication:
+
+1. **Identify the communication type** from the request
+2. **Load the appropriate guideline file** from the `examples/` directory:
+    - `examples/3p-updates.md` - For Progress/Plans/Problems team updates
+    - `examples/company-newsletter.md` - For company-wide newsletters
+    - `examples/faq-answers.md` - For answering frequently asked questions
+    - `examples/general-comms.md` - For anything else that doesn't explicitly match one of the above
+3. **Follow the specific instructions** in that file for formatting, tone, and content gathering
+
+If the communication type doesn't match any existing guideline, ask for clarification or more context about the desired format.
+
+## Keywords
+3P updates, company newsletter, company comms, weekly update, faqs, common questions, updates, internal comms

adapters-output/cursor/learning-assessor.md

@@ -0,0 +1,93 @@
+# Learning Assessor
+
+## Description
+帮助创建学习评估工具，包括测验题目、评估标准、评分 rubric 和学习分析。适用于评估学习效果、设计考试题目或分析学习数据。
+
+## When to Use
+Use this skill when the user asks about: 帮助创建学习评估工具，包括测验题目、评估标准、评分 rubric 和学习分析。适用于评估学习效果、设计考试题目或分析学习数据。
+
+## Instructions
+
+# 学习评估技能
+
+## 概述
+
+本技能帮助您创建各种学习评估工具，包括测验题目、评估标准、评分 rubric 和学习分析。
+
+**关键词**: 学习评估、测验设计、评分标准、rubric、学习分析、考试题目
+
+## 核心功能
+
+### 1. 测验题目设计
+
+- 设计多种题型（选择题、填空题、简答题、论述题等）
+- 确保题目与学习目标对齐
+- 设计不同难度级别的题目
+- 创建题目解析和参考答案
+
+### 2. 评估标准制定
+
+- 制定清晰的评估标准
+- 设计评分细则和权重分配
+- 创建评分 rubric（评分量规）
+- 确保评估的客观性和一致性
+
+### 3. 学习分析
+
+- 分析学习数据和学习趋势
+- 识别学习难点和薄弱环节
+- 提供个性化学习建议
+- 生成学习报告和反馈
+
+### 4. 评估工具创建
+
+- 创建在线测验和问卷
+- 设计项目评估表
+- 创建同伴评估工具
+- 设计自我评估工具
+
+## 使用指南
+
+### 题目设计原则
+
+1. **目标对齐**: 每道题目都应对应明确的学习目标
+2. **难度梯度**: 题目应覆盖不同认知层次（记忆、理解、应用、分析、评价、创造）
+3. **清晰明确**: 题目表述清晰，避免歧义
+4. **公平性**: 确保题目对所有学习者公平
+5. **有效性**: 题目应能有效测量目标知识和技能
+
+### Rubric 设计
+
+Rubric 应包含：
+
+- **评估维度**: 要评估的具体方面
+- **表现等级**: 不同表现水平的描述
+- **评分标准**: 每个等级的评分标准
+- **权重分配**: 各维度的权重
+
+### 学习分析维度
+
+- **知识掌握度**: 对知识点的掌握情况
+- **技能应用**: 技能的应用水平
+- **学习进度**: 学习进度和完成情况
+- **学习困难**: 识别学习中的困难点
+- **改进建议**: 提供针对性的改进建议
+
+## 输出格式
+
+评估工具应包含：
+
+- **评估目标**: 明确要评估的内容
+- **评估方式**: 使用的评估方法和工具
+- **评估标准**: 详细的评分标准或 rubric
+- **评估题目**: 具体的评估题目（如适用）
+- **分析报告**: 学习分析和反馈建议
+
+## 最佳实践
+
+- 使用多种评估方式，避免单一化
+- 设计形成性评估，及时反馈
+- 确保评估标准清晰、可操作
+- 提供建设性的反馈意见
+- 关注学习过程，不仅看结果
+- 鼓励自我评估和同伴评估