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

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

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?

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:

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:
   code

   ├── 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