Extract methodologies from documents or examples to create executable skills
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:
## 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?
## 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:
## 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:
Read the article
Identify: This is a How-to type (has steps, teaching intent)
Extract:
Goal: Write clear, useful commit messages
Steps: Use conventional format, separate subject/body, etc.
Quality criteria: Subject < 50 chars, imperative mood, etc.
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:
Identify: This is an example (finished work, no teaching intent)
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
Extract quality characteristics:
Title = specific tech + problem solved
One idea per paragraph
Code:text ratio ~40:60
Personal anecdotes for credibility
Reverse engineer steps:
Start with a real problem you solved
Write the solution first, then the setup
Add code samples progressively
etc.
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
Always validate first - Not all content is suitable for skill extraction
Identify the path early - Methodology doc vs Example require different approaches
Be specific - Vague skills are useless; include concrete steps and criteria
Preserve the source - Always credit where the knowledge came from
Ask for clarification - If unsure about user intent, ask before proceeding
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 executeddon't have the plugin yet? install it then click "run inline in claude" again.