skill-from-notebook

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 executed