Video Digest

/video-digest

Intelligently triage new videos from subscribed YouTube channels, process selectively based on relevance, and generate a daily digest with watch recommendations.

Usage

/video-digest                    # Full triage and processing
/video-digest --triage-only      # Score videos without processing
/video-digest --report           # Show current queue status
/video-digest --watched <video>  # Mark video as watched (removes from queue)

Examples

/video-digest
/video-digest --triage-only
/video-digest --watched "YouTube - AI Security Patterns"

Model Strategy

Instructions

Phase 1: Gather New Videos

Model: Haiku (parallel subagents)

1. Read subscriptions from .claude/subscriptions.yaml

2. For each channel (in parallel), fetch RSS feed:

   https://www.youtube.com/feeds/videos.xml?channel_id={{channel_id}}
   

   Use WebFetch with prompt: "Extract video entries: title, video_id, published_date, description (first 500 chars)"

3. Identify new videos:

   • Compare video IDs against last_video_id
   • Select videos published since last check
   • If first check, take only most recent video

4. Collect candidates with basic metadata:

   • video_id, title, description, duration (if available)
   • channel_name, channel_trust_score, always_watch

Phase 2: Rapid Triage

Model: Haiku

For each candidate video, compute triage score:

Scoring Algorithm

TRParentCorpE_SCORE = (
    PROJECT_RELEVANCE * 0.35 +    # 0-100
    DOMAIN_RELEVANCE * 0.25 +     # 0-100
    FRESHNESS_BOOST * 0.20 +      # 0-100
    CHANNEL_TRUST * 0.20          # 0-100 (from trust_score * 5)
)

Relevance Matching

Project Relevance (read .claude/context/projects.md):

Match title + description against project keywords:

Domain Relevance (read .claude/rules/tag-taxonomy.md domain/ section):

Match against domain keywords:

• domain/engineering: systems, architecture, design, modernisation
• domain/data: analytics, data products, streaming, Kafka, databases
• domain/cloud: AWS, Azure, infrastructure, serverless, containers
• domain/security: IAM, encryption, compliance, threats, vulnerabilities
• domain/ai: LLM, agents, machine learning, Claude, GPT, automation

Freshness Boost:

• Check if topic keywords appear in notes modified in last 14 days
• Higher score = more recently active topics
• Use Graph search: node .claude/scripts/graph-query.js --search="<keywords>" --since=$(date -v-14d +%Y-%m-%d) --json

Channel Trust:

• Use trust_score from subscriptions.yaml (0-20, default 10)
• Scale to 0-100 by multiplying by 5

Boost Keywords

Apply additional boosts from triage_settings.boost_keywords:

boost_keywords:
  - keyword: "architecture"
    boost: 10
  - keyword: "Claude Code"
    boost: 15

Never Process Keywords

Skip videos containing triage_settings.never_process_keywords:

never_process_keywords:
  - "reaction"
  - "drama"
  - "podcast"
  - "unboxing"

Duration Filtering

Skip videos outside minimum_duration / maximum_duration thresholds.

Category Assignment

Phase 3: Selective Processing

Model: Sonnet (parallel for Worth Processing tier)

Must Watch (80-100)

Do NOT process automatically. Instead:

1. Update video queue (.claude/video-queue.yaml):

   must_watch:
     - video_id: "abc123"
       title: "Video Title"
       url: "https://youtube.com/watch?v=abc123"
       channel: "Channel Name"
       score: 92
       first_recommended: "2026-02-05T08:00:00Z"
       always_watch_channel: false
       reasoning:
         - "Directly relevant to [[Project - AlertHub]] - discusses AI agent security"
         - "Knowledge gap: No vault content on 'AI firewall' patterns"
         - "Channel trust: 2.8 nodes/video historical yield"
       potential_nodes: 4
   

2. Include in digest with full reasoning

Worth Processing (50-79)

Launch parallel /youtube processing:

1. For each video in this tier, invoke /youtube <url>:

   • Follow full /youtube skill workflow
   • Create YouTube node with transcript analysis
   • Spawn Concept/Pattern nodes as appropriate

2. Track results:

   • Count spawned nodes
   • Update processing_stats in subscriptions.yaml

Quick Capture (25-49)

Model: Haiku

Create minimal Weblink note:

Filename: Weblink - {{sanitised title}}.md

---
type: Reference
title: "{{title}}"
url: "{{youtube_url}}"
domain: youtube.com
createdAt: "{{ISO timestamp}}"
description: "{{brief summary from description}}"
created: { { DATE } }
modified: { { DATE } }
tags:
  - video
  - activity/research

relatedTo: []
---

# {{title}}

**Channel:** {{channel name}}
**Duration:** {{duration}}
**Source:** [Watch on YouTube]({{url}})

## Summary

{{2-3 sentence summary based on title and description}}

## Relevance

Quick captured due to moderate relevance (score: {{score}}/100).

_Full processing not warranted based on triage criteria._

Skip (0-24)

Log to digest only. No files created.

Phase 4: Queue Management

Check Must Watch Expiry

1. Read .claude/video-queue.yaml

2. For each video in must_watch:

   • If always_watch_channel: true → Keep in must_watch
   • If age > must_watch_expiry_days (default 5) → Move to backlog

3. Update queue file with moves

Backlog Structure

backlog:
  - video_id: "ghi789"
    title: "Older Video"
    url: "https://youtube.com/watch?v=ghi789"
    channel: "Some Channel"
    expired_from_must_watch: "2026-02-05"
    original_score: 85
    reasoning:
      - "Was relevant to [[Project - Beta]]"

Phase 5: Generate Digest

Model: Sonnet

Add ## Video Digest section to today's daily note.

1. Find daily note: Check both formats:
   • Daily/{{year}}/{{YYYY-MM-DD}}.md (actual format used)
   • Daily/{{year}}/Daily - {{YYYY-MM-DD}}.md (documented format)
2. Create if missing: Use /daily skill
3. Insert digest section (before ## End of Day Review if present, otherwise at end)

Digest Template

## Video Digest

_Generated at {{timestamp}}_

### 📊 Summary

| Category         | Count | Action                       |
| ---------------- | ----- | ---------------------------- |
| Must Watch       | {{n}} | Review recommendations below |
| Worth Processing | {{n}} | Auto-processed               |
| Quick Capture    | {{n}} | Weblink created              |
| Skipped          | {{n}} | Not relevant                 |

### 🎯 Must Watch

{{For each must-watch video:}}

#### [[YouTube - {{title}}]] _(not yet created)_

**Channel:** {{channel}} | **Duration:** {{duration}} | **Score:** {{score}}/100

**Why watch:**
{{For each reasoning point:}}

- {{reasoning}}

**If skipped:** Will extract ~{{potential_nodes}} concepts including {{top concepts}}

---

### ✅ Auto-Processed

| Video | Channel | Score | Nodes Created |
| ----- | ------- | ----- | ------------- |

{{For each processed video:}}
| [[YouTube - {{title}}]] | {{channel}} | {{score}} | {{nodes_count}} |

### 📎 Quick Captures

{{For each quick capture:}}

- [[Weblink - {{title}}]] - {{brief reason}}

### ⏭️ Skipped

| Video | Channel | Reason |
| ----- | ------- | ------ |

{{For each skipped video:}}
| "{{title}}" | {{channel}} | {{skip_reason}} |

{{If backlog not empty:}}

### ⏳ When You Get Time (Backlog)

Videos that expired from Must Watch after {{expiry_days}} days:

| Video | Channel | Original Score | Days in Queue |
| ----- | ------- | -------------- | ------------- |

{{For each backlog video:}}
| [[YouTube - {{title}}]] | {{channel}} | {{score}} | {{days}} |

Phase 6: Update State

1. Update subscriptions.yaml:

   • Set last_checked to current timestamp
   • Set last_video_id to most recent video per channel
   • Increment processing_stats counters

2. Update video-queue.yaml:

   • Add new must-watch videos
   • Move expired videos to backlog
   • Remove watched videos (via --watched flag)

Handling --watched Flag

When invoked as /video-digest --watched <video>:

1. Parse video identifier (title or video_id)
2. Search must_watch and backlog in queue
3. Remove matching entry
4. Confirm removal

Handling --report Flag

When invoked as /video-digest --report:

1. Read .claude/video-queue.yaml
2. Display summary:

Video Queue Status
==================

Must Watch: {{count}}
{{For each:}}
  - "{{title}}" ({{channel}}) - Score: {{score}} - {{days_old}} days old

Backlog: {{count}}
{{For each:}}
  - "{{title}}" ({{channel}}) - Expired {{days_ago}} days ago

Last Digest: {{timestamp}}

Handling --triage-only Flag

When invoked as /video-digest --triage-only:

• Execute Phases 1-2 only
• Output scoring results without processing
• Do not update subscriptions.yaml (except last_checked)
• Useful for testing triage algorithm

Quality Standards

• Always generate digest in daily note
• Always provide reasoning for must-watch recommendations
• Always update queue state after execution
• Never process must-watch automatically (user should decide)
• Never create duplicate YouTube nodes for already-processed videos
• Use UK English throughout
• Update subscriptions.yaml after every run
• Track spawned nodes for trust score calibration

Example Output

For a run with 2 channels, 8 new videos:

Video Digest Results
====================

Checked 2 channels, found 8 new videos.

📊 Triage Results:
  Must Watch: 1
    - "AI Security for Autonomous Agents" (IndyDevDan) - Score: 92
  Worth Processing: 2
    - "AWS Bedrock Deep Dive" - Score: 68
    - "Kafka Streaming Patterns" - Score: 55
  Quick Capture: 2
  Skipped: 3

✅ Processed 2 videos:
  - [[YouTube - AWS Bedrock Deep Dive]] → 2 concepts, 1 pattern
  - [[YouTube - Kafka Streaming Patterns]] → 1 concept

📎 Created 2 quick captures:
  - [[Weblink - Tech News Weekly]]
  - [[Weblink - Developer Productivity Tips]]

📝 Updated today's daily note with digest.
📋 1 video added to must-watch queue.

Error Handling

• RSS fetch fails: Log warning, continue to next channel
• Transcript unavailable: Process with description-only analysis
• Daily note missing: Create using /daily skill
• Queue file missing: Create with empty arrays
• Config missing: Use default thresholds

Related Skills

• /rss-check - Channel subscription management
• /youtube - Full video processing
• /daily - Daily note creation
• /schedule - Scheduled execution setup