笔记本上的技能
- 作者仓库星标 1,408
- 作者仓库 skill-from-masters
- 领域
- 文档
- 作者声明的智能体
- 未找到明确声明;不据此推断已兼容或已测试
- 静态检查
- 88 / 100 · 启发式扫描,不代表运行安全
- 运行环境证据
- 未执行;当前没有隔离运行测试证据
- 作者 / 版本 / 许可证
- @GBSOSS · 未声明许可证
- 上下文用量评级
- 低消耗
- 接入复杂程度
- 需手动接入
- 是否需要外部接口密钥
- 不需要
- 兼容的系统
- Docker
- 运行环境要求
- Docker
- 检测到的文件与系统行为
-
- 只读
- 允许写入 / 修改
- 命令执行
- 网络行为
- 仅限本地
- 安装命令数
- 无(仅作为资料)
需要注意: 未声明工具权限范围;实际权限由运行环境决定。
第 0 步:识别输入类型
关键的第一步 - 确定使用哪个处理路径: 路径 A 指标(方法文档):包含“如何”、“步骤”、“方法”、“指南”等词语 具有编号列表或步骤序列 具有教学意图
# Skill from Notebook
Extract actionable methodologies from learning materials (documents, articles, videos) or quality examples (blog posts, designs, code) to generate reusable Skills.
**Core Philosophy**: NotebookLM helps you understand. This skill helps you **do**.
## When to Use
When users want to turn knowledge into executable skills:
- "I just read this article about code review, help me create a skill from it"
- "Here's a great technical blog post, extract the writing methodology"
- "Turn this PDF guide into a skill I can reuse"
- "Learn from this example and create a skill to produce similar output"
## Supported Input Types
| Type | How to Process |
|------|----------------|
| Local files | PDF, Word, Markdown - Read directly |
| Web URL | WebFetch to extract content |
| YouTube | Use yt-dlp for subtitles, Whisper if unavailable |
| NotebookLM link | Browser automation to extract notes/summaries |
| Example/Output | Reverse engineer the methodology |
## Step 0: Identify Input Type
**Critical first step** - Determine which processing path to use:
```
User Input
│
├─ Has teaching intent? ("how to", "steps", "guide")
│ └─ YES → Path A: Methodology Document
│
├─ Is a finished work? (article, design, code, proposal)
│ └─ YES → Path B: Example (Reverse Engineering)
│
└─ Neither? → Tell user this content is not suitable
```
**Path A indicators** (Methodology Document):
- Contains words like "how to", "steps", "method", "guide"
- Has numbered lists or step sequences
- Written with teaching intent
- Describes "what to do"
**Path B indicators** (Example/Output):
- Is a complete work/artifact
- No teaching intent
- Is "the thing itself" rather than "how to make the thing"
- Examples: a well-written blog post, a polished proposal, a code project
---
## Path A: Extract from Methodology Document
### A1: Validate Document Suitability
Check if the document is suitable for skill generation (must meet at least 2):
- [ ] Has clear goal/outcome
- [ ] Has repeatable steps/process
- [ ] Has quality criteria
- [ ] Has context/scenario description
**If not suitable**: Tell user honestly and explain why.
### A2: Identify Skill Type
| Type | Characteristics | Examples |
|------|-----------------|----------|
| **How-to** | Clear step sequence, input→output | Deploy Docker, Configure CI/CD |
| **Decision** | Conditions, trade-offs, choices | Choose database, Select framework |
| **Framework** | Mental model, analysis dimensions | SWOT, 5W1H, First Principles |
| **Checklist** | Verification list, pass/fail criteria | Code review checklist, Launch checklist |
### A3: Extract Structure by Type
**For How-to:**
- Prerequisites
- Step sequence (with expected output per step)
- Final expected result
- Common errors
**For Decision:**
- Decision factors
- Options with pros/cons
- Decision tree/flowchart
- Recommended default
**For Framework:**
- Core concepts
- Analysis dimensions
- Application method
- Limitations
**For Checklist:**
- Check items with criteria
- Priority levels
- Commonly missed items
### A4: Generate Skill
Use this template:
```markdown
## Applicable Scenarios
[When to use this skill]
## Prerequisites
- [What's needed before starting]
## Steps
1. [Step 1] - [Expected outcome]
2. [Step 2] - [Expected outcome]
...
## Quality Checkpoints
- [ ] [Checkpoint 1]
- [ ] [Checkpoint 2]
## Common Pitfalls
- [Pitfall 1]: [How to avoid]
## Source
- Document: [name/URL]
- Extracted: [timestamp]
```
---
## Path B: Reverse Engineer from Example
When input is a finished work (not a tutorial), reverse engineer the methodology.
### B1: Identify Output Type
What kind of artifact is this?
- Technical blog post
- Product proposal/PRD
- Academic paper
- Code architecture
- Design document
- Other: [specify]
### B2: Analyze Structure
Break down the example:
```
Structure Analysis:
├── [Part 1]: [Function] - [Proportion %]
├── [Part 2]: [Function] - [Proportion %]
├── [Part 3]: [Function] - [Proportion %]
└── [Part N]: [Function] - [Proportion %]
```
Questions to answer:
- How many parts does it have?
- What's the function of each part?
- What's the order and proportion?
### B3: Extract Quality Characteristics
What makes this example **good**?
| Dimension | Questions |
|-----------|-----------|
| Structure | How is content organized? |
| Style | Tone, word choice, expression? |
| Technique | What methods make it effective? |
| Logic | How does information flow? |
| Details | Small but important touches? |
### B4: Reverse Engineer the Process
Deduce: To create this output, what steps are needed?
```markdown
## Deduced Production Steps
1. [Step 1]: [What to do] - [Key point]
2. [Step 2]: [What to do] - [Key point]
...
## Key Decisions
- [Decision 1]: [Options] - [This example chose X because...]
## Reusable Techniques
- [Technique 1]: [How to apply]
- [Technique 2]: [How to apply]
```
### B5: Generate Skill
Use this template for reverse-engineered skills:
```markdown
## Output Type
[What kind of artifact this produces]
## Applicable Scenarios
[When to create this type of output]
## Structure Template
1. [Part 1]: [Function] - [~X%]
2. [Part 2]: [Function] - [~X%]
...
## Quality Characteristics (Learned from Example)
- [Characteristic 1]: [How it manifests]
- [Characteristic 2]: [How it manifests]
## Production Steps
1. [Step 1]: [What to do] - [Tips]
2. [Step 2]: [What to do] - [Tips]
...
## Checklist
- [ ] [Check item 1]
- [ ] [Check item 2]
## Reference Example
- Source: [name/URL]
- Analyzed: [timestamp]
```
---
## Example: Path A (Methodology Document)
**User**: "Extract a skill from this article about writing good commit messages"
**Process**:
1. Read the article
2. Identify: This is a **How-to** type (has steps, teaching intent)
3. Extract:
- Goal: Write clear, useful commit messages
- Steps: Use conventional format, separate subject/body, etc.
- Quality criteria: Subject < 50 chars, imperative mood, etc.
4. Generate skill with steps and checklist
---
## Example: Path B (Reverse Engineering)
**User**: "Here's a great technical blog post. Learn from it and create a skill for writing similar posts."
**Process**:
1. Identify: This is an **example** (finished work, no teaching intent)
2. Analyze structure:
```
├── Hook: Real pain point (2-3 sentences)
├── Problem: 3 sentences on the core issue
├── Solution: Conclusion first, then details
├── Code: Each snippet < 20 lines, with comments
├── Pitfalls: 3 common errors
└── Summary: One-line takeaway
```
3. Extract quality characteristics:
- Title = specific tech + problem solved
- One idea per paragraph
- Code:text ratio ~40:60
- Personal anecdotes for credibility
4. Reverse engineer steps:
- Start with a real problem you solved
- Write the solution first, then the setup
- Add code samples progressively
- etc.
5. Generate skill: "How to Write a Technical Blog Post"
---
## Advanced: Multi-Example Learning
When user provides multiple examples of the same type:
```
Example A ──┐
Example B ──┼──> Extract commonalities ──> Core methodology
Example C ──┘ │
▼
Analyze differences ──> Style variants / Optional techniques
```
This produces more robust, generalizable skills.
---
## Important Notes
1. **Always validate first** - Not all content is suitable for skill extraction
2. **Identify the path early** - Methodology doc vs Example require different approaches
3. **Be specific** - Vague skills are useless; include concrete steps and criteria
4. **Preserve the source** - Always credit where the knowledge came from
5. **Ask for clarification** - If unsure about user intent, ask before proceeding
6. **Quality over speed** - Take time to truly understand the content
## What This Skill is NOT
- NOT a summarizer (that's NotebookLM's job)
- NOT a document converter
- It's about extracting **actionable methodology** that can be repeatedly executed
章节与文件索引
按说明文件中的顺序排列。
何时使用
支持的输入类型
第 0 步:识别输入类型
A1:验证文件的适用性
A2:识别技能类型
文件/命令 -> notes/summaries · Example/Output · work/artifact · goal/outcome · steps/process · context/scenario · CI/CD · pass/fail
内容校验值 -> de065f1776ed
当前原文的自动摘译,尚未人工审校。
何时使用
当用户想要将知识转化为可执行的技能时:“我刚刚读了这篇关于代码审查的文章,帮我从中创建一项技能”“这是一篇很棒的技术博客文章,提取写作方法”“将这个 PDF 指南变成我可以重用的技能”“从这个示例中学习并创建一项产生类似输出的技能”
支持的输入类型
类型 · 如何处理本地文件 · PDF、Word、Markdown - 直接读取 Web URL · WebFetch 提取 YouTube 内容 · 使用 yt-dlp 获取字幕,如果不可用 NotebookLM 链接则私聊 · 浏览器自动化提取注释/摘要
A1:验证文件的适用性
检查文档是否适合技能生成(必须至少满足 2 项): [ ] 具有明确的目标/结果 [ ] 具有可重复的步骤/过程 [ ] 具有质量标准 [ ] 具有背景/场景描述
A2:识别技能类型
类型·特征·示例操作方法·清晰的步骤顺序,输入→输出·部署Docker,配置CI/CD决策·条件,权衡,选择·选择数据库,选择框架框架·心智模型,分析维度·SWOT,5W1H,第一原则清单·验证清单,通过/失败标准·代码审查清单,启动清单