skill-from-notebook

SKILL.md

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