ClawNetClawNet

Active Learning System Generator

Purpose

This skill transforms any book (PDF or EPUB) into a comprehensive active learning system within Obsidian. It creates 9 types of learning materials for each book section:

  1. Overview - Pre-reading framework
  2. Core Concepts - Key ideas extraction
  3. Mind Maps - Visual relationship mapping
  4. SOPs - Standard operating procedures for practice
  5. Similar Resources - Related books and references
  6. Counter-Arguments - Critical thinking perspectives
  7. Open Questions - Deep exploration prompts
  8. Practice Exercises - 5 question types (comprehension, inference, Socratic, critical, application)
  9. Discussion Records - Conversation tracking templates

When to Use This Skill

Use this skill when a user says they want to:

  • "Deeply understand a book"
  • "Create a learning system for [book]"
  • "Generate exercises and practice materials"
  • "Build a knowledge base for [topic]"
  • "Study [book] with active recall"

The skill should also be used when:

  • The user provides a book path (PDF/EPUB)
  • They want to integrate with Obsidian
  • They need systematic learning materials
  • The book is lengthy (1000+ pages)

How to Use This Skill

Step 1: Analyze the Book

  1. Check file format and integrity

    # Use bundled script to analyze book
scripts/analyze_book.py --path "/path/to/book.pdf"
    • Determines if PDF is text-based or scanned
    • Counts total pages
    • Estimates content extractability
    • Generates reading difficulty score

  2. Extract book structure

    scripts/extract_structure.py --path "/path/to/book.pdf" --output "/tmp/structure.json"
    • Identifies table of contents
    • Detects chapter boundaries
    • Creates section mapping
    • For long books: creates processing chunks (100-page segments)

  3. Generate book overview

    • Uses first 50 pages and last 20 pages
    • Identifies core themes and concepts
    • Creates reading difficulty assessment
    • Suggests learning timeline

Step 2: Process Content in Chunks (for large books)

For books >300 pages, process in 100-page chunks to ensure completeness:

# Process each chunk
scripts/process_chunk.py --chunk 1 --pages 1-100 --book "/path/to/book.pdf"
scripts/process_chunk.py --chunk 2 --pages 101-200 --book "/path/to/book.pdf"
# ... etc

Integrity Check: After each chunk, verify:

  • Number of sections/chapters extracted
  • Core concepts identified
  • Practice exercises generated
  • Flag any chunks with low extraction quality

Step 3: Generate Learning Materials

For each book section (or chunk), generate all 9 document types:

# Generate all materials for a section
scripts/generate_section.py --section 1 --type all --book "/path/to/book.pdf"

This creates:

  • 00-章节总结.md - Summary template
  • 01-核心观点.md - Core concepts extraction
  • 02-思维导图.md - Mermaid mind maps
  • 03-发展链路.md - SOPs and practice plans
  • 04-相似推荐.md - Related resources
  • 05-反观点.md - Critical perspectives
  • 06-开放性问题.md - Deep exploration questions
  • 07-练习题.md - 5 types of exercises
  • 08-讨论记录.md - Discussion templates

Step 4: Create Knowledge Base Structure

scripts/setup_obsidian.py --book "Book Title" --author "Author" --category "Category" --output "/path/to/vault/读书笔记/"

Creates:

  • Main directory structure
  • Index file with book list
  • Knowledge point index
  • Learning progress tracker
  • 5-year roadmap template

Step 5: Integrity Verification

Critical Step: Verify all content was generated completely

scripts/verify_completion.py --book "/path/to/book.pdf" --output "/path/to/vault/读书笔记/Book/"

Checks:

  • ✅ All 9 document types created
  • ✅ Number of sections matches book structure
  • ✅ Exercise count (should be 10-15 per section)
  • ✅ SOP completeness (should have 3-5 per section)
  • ✅ Cross-links between documents
  • ✅ Page coverage (for long books: all chunks processed)

If verification fails: Re-run generation for missing sections

Step 6: Package and Deliver

scripts/package_system.py --book-path "/path/to/vault/读书笔记/Book/" --output "/path/to/deliverable.zip"

Creates distributable package with:

  • All generated markdown files
  • Setup instructions
  • Quick start guide
  • Learning roadmap

Handling Large Books (1000+ pages)

Chunk Processing Strategy

For books >300 pages:

  1. Automatic Chunk Detection

    • Script divides book into 100-page segments
    • Preserves chapter boundaries (doesn't split chapters across chunks)
    • Creates chunk mapping file

  2. Sequential Processing

    # Process chunk by chunk
for chunk_id in range(1, total_chunks + 1):
    scripts/process_chunk.py --chunk chunk_id --book book.pdf
    scripts/verify_chunk.py --chunk chunk_id  # Verify before proceeding

  3. Integrity Checkpoints

    • After each chunk: verify extraction quality >80%
    • If quality <80%, use OCR fallback for that chunk
    • Log any chapters/sections that couldn't be extracted

  4. Content Stitching

    • Merge chunk outputs maintaining logical flow
    • Ensure cross-chapter links work correctly
    • Generate overview that covers entire book

Fallback for Low Quality Extraction

If a book has poor text extraction (scanned pages, images):

# Use OCR fallback
scripts/extract_with_ocr.py --chunk problematic_chunk --book book.pdf

User Notification: If OCR is used, inform user:

  • "This book required OCR processing. Generated content may have lower accuracy."
  • Suggest finding a text-based version if available

Adaptability for Different Book Types

The skill automatically adapts based on book type:

1. Theory/Concept Books (e.g., psychology, philosophy)

  • Emphasis on: understanding, critical thinking, application
  • More Socratic questions
  • More counter-arguments
  • Application exercises focus on real-life scenarios

2. Practical/How-to Books (e.g., self-help, business)

  • Emphasis on: practice plans, SOPs, implementation
  • More SOPs with step-by-step instructions
  • More practice exercises
  • Discussion focused on obstacles

3. Spiritual/Mindfulness Books (e.g., meditation, awakening)

  • Emphasis on: direct experience, practice, integration
  • More experiential exercises
  • Open questions for personal exploration
  • Lifestyle integration guidance

4. Academic/Textbooks

  • Emphasis on: comprehension, structure, knowledge mapping
  • More detailed mind maps
  • Comprehensive summaries
  • Critical analysis exercises

5. Fiction/Literature

  • Emphasis on: themes, characters, interpretation, reflection
  • Character analysis exercises
  • Thematic exploration questions
  • Personal reflection prompts
  • Discussion templates for book clubs

Bundled Resources

scripts/

  • analyze_book.py - Analyzes book format and readability
  • extract_structure.py - Extracts table of contents and chapters
  • process_chunk.py - Processes 100-page segments
  • generate_section.py - Generates all 9 document types for a section
  • setup_obsidian.py - Creates Obsidian vault structure
  • verify_completion.py - Integrity check for generated content
  • package_system.py - Packages everything for delivery

references/

  • book_types.md - Guidance for different book genres
  • question_templates.md - Templates for 5 question types
  • sop_templates.md - Templates for SOPs
  • mindmap_templates.md - Mermaid diagram templates
  • integrity_checklist.md - Verification checklist

assets/

  • learning-roadmap-template.md - Overall learning path template
  • progress-tracker-template.md - Progress tracking spreadsheet
  • summary-template.md - Chapter summary template

Usage Example

User Request: "我想深入学习《思考，快与慢》，文件在~/Books/thinking.pdf，请帮我建立学习系统"

Skill Response:

  1. Analyze the book:

    python scripts/analyze_book.py --path "~/Books/thinking.pdf"

    Output: "Book detected: 512 pages, text-based PDF, psychology genre"

  2. Extract structure:

    python scripts/extract_structure.py --path "~/Books/thinking.pdf"

    Output: "Found 38 chapters, 5 parts, generating 5 learning sections"

  3. Process each section:

    for i in {1..5}; do
  python scripts/generate_section.py --section $i --book "~/Books/thinking.pdf"
done

  4. Setup Obsidian structure:

    python scripts/setup_obsidian.py --book "思考，快与慢" --author "丹尼尔·卡尼曼" --category "心理学" --output "~/Documents/OB/读书笔记/"

  5. Verify completion:

    python scripts/verify_completion.py --book "~/Books/thinking.pdf" --output "~/Documents/OB/读书笔记/心理学/思考，快与慢/"

    Output: "✅ Complete! 5 sections, 45 documents generated, 180 exercises created"

  6. Package and present:

    • Create zip file with all materials
    • Generate quick start guide
    • Present learning roadmap to user

Quality Assurance

Integrity Check Process

After generating all materials, always run verification:

# In scripts/verify_completion.py

def verify_book_system(book_path, output_dir):
    """Comprehensive verification of generated learning system"""
    
    issues = []
    
    # Check 1: All sections processed
    expected_sections = count_sections(book_path)
    actual_sections = count_directories(output_dir)
    if actual_sections < expected_sections * 0.9:
        issues.append(f"Missing sections: {expected_sections - actual_sections}")
    
    # Check 2: All document types present
    for section in get_sections(output_dir):
        docs = os.listdir(section)
        required_docs = [
            "00-章节总结.md", "01-核心观点.md", "02-思维导图.md",
            "03-发展链路.md", "04-相似推荐.md", "05-反观点.md",
            "06-开放性问题.md", "07-练习题.md", "08-讨论记录.md"
        ]
        missing = [d for d in required_docs if d not in docs]
        if missing:
            issues.append(f"Section {section} missing: {missing}")
    
    # Check 3: Exercise count
    exercise_count = count_exercises(output_dir)
    expected_exercises = expected_sections * 10
    if exercise_count < expected_exercises * 0.8:
        issues.append(f"Low exercise count: {exercise_count}/{expected_exercises}")
    
    # Check 4: Page coverage (for chunked books)
    if is_chunked(book_path):
        coverage = check_page_coverage(book_path, output_dir)
        if coverage < 0.95:
            issues.append(f"Low page coverage: {coverage * 100:.1f}%")
    
    # Check 5: Cross-links
    link_count = count_cross_links(output_dir)
    expected_links = expected_sections * 5
    if link_count < expected_links * 0.7:
        issues.append(f"Insufficient cross-links: {link_count}/{expected_links}")
    
    return {
        "complete": len(issues) == 0,
        "issues": issues,
        "stats": {
            "sections": actual_sections,
            "exercises": exercise_count,
            "links": link_count,
            "coverage": coverage if is_chunked(book_path) else 1.0
        }
    }

User Report Format

After verification, present results to user:

📚 书籍分析完成！

📖 书籍信息：
- 书名：《XXX》
- 页数：512页
- 类型：心理学/哲学/实践指南
- 处理方式：文本提取（质量：95%）

✅ 系统生成统计：
- 学习章节：5大部分
- 生成文档：45个（9种类型×5章节）
- 练习题：180道（平均每章36道）
- 思维导图：5个
- SOP指南：15个
- 预计学习时间：3-6个月

🔍 完整性检查：
- ✅ 所有章节已处理
- ✅ 所有文档类型已生成
- ✅ 练习题数量达标
- ✅ 交叉链接已建立
- ⚠️  建议：第3章练习题略少，已补充

📍 文件位置：
~/Documents/OB/读书笔记/类别/书名/

🚀 下一步：
1. 阅读00-概览.md（15分钟）
2. 阅读第一部分并完成练习题
3. 开始呼吸觉察实践

Troubleshooting

Common Issues and Solutions

Issue 1: Low extraction quality

  • Symptom: Script reports <80% text extraction
  • Solution: Use OCR fallback + notify user
  • Script: scripts/extract_with_ocr.py

Issue 2: Missing sections

  • Symptom: Verification shows missing chapters
  • Solution: Re-run extraction for missing pages
  • Script: scripts/extract_missing.py --pages start-end

Issue 3: Too many exercises

  • Symptom: Generated 50+ exercises for one section
  • Solution: Use filter to select most important 10-15
  • Script: scripts/filter_exercises.py --section X --max 15

Issue 4: Broken cross-links

  • Symptom: Obsidian shows broken links
  • Solution: Run link repair script
  • Script: scripts/fix_links.py --vault "/path/to/vault"

Issue 5: User wants customization

  • Solution: Provide configuration file
  • Template: references/config_template.md

Best Practices

For Skill Users

  1. Always run verification after generation
  2. Start with overview before diving in
  3. Don't skip exercises - they're core to learning
  4. Adapt timeline to your schedule (3-6 months is flexible)
  5. Use discussion records for conversations with AI

For Skill Development

  1. Test with multiple book types before release
  2. Include fallback mechanisms for low-quality extraction
  3. Make verification mandatory - don't skip it
  4. Provide customization options for power users
  5. Document limitations clearly (e.g., scanned PDFs)

Limitations

Current Limitations

  1. Scanned PDFs: OCR accuracy ~85-90%, may miss nuances
  2. Complex layouts: Books with multi-column layouts may extract out of order
  3. Images/Diagrams: Text descriptions only, can't reproduce images
  4. Fiction/Poetry: Less effective than non-fiction (system designed for concept-heavy books)
  5. Language: Currently optimized for Chinese books, may need adaptation for other languages

Future Enhancements

  • Multi-language support (English, Japanese, etc.)
  • Better handling of complex layouts
  • Image description generation for diagrams
  • Audio book support
  • Interactive exercise generation (with answer keys)
  • Progress analytics dashboard
  • Spaced repetition schedule integration

Example Skill Trigger Phrases

These user queries should trigger this skill:

  • "我想深入学习《XXX》，请帮我建立学习系统"
  • "为《XXX》生成主动学习材料"
  • "我想真正理解这本书，需要练习题和讨论"
  • "这本书太厚了，帮我分解学习"
  • "为我的Obsidian创建这本书的知识库"
  • "我想批判性地学习这本书"

Conclusion

This skill transforms passive reading into active, deep learning by generating comprehensive learning systems for any book. It handles books of any size through chunk processing and includes rigorous integrity checks to ensure completeness.

Remember: Always run verification after generation and be transparent with users about any quality issues or limitations.