Get Y2b Clips

YouTube Nuggets Extractor

Extract the most valuable clips ("nuggets") from YouTube videos automatically. Analyzes transcripts to find high-value segments based on controversy, insightful analysis, or user-specified topics.

When to Use This Skill

Activate when the user:

• Wants to extract "best clips", "highlights", or "nuggets" from a YouTube video
• Asks to find "interesting moments" or "valuable segments"
• Wants controversial takes, insights, or specific topics from a video
• Provides a YouTube URL and mentions clips, segments, or highlights

Dependencies Check

ALWAYS check dependencies first:

# Check for yt-dlp
command -v yt-dlp || echo "MISSING: yt-dlp"

# Check for ffmpeg
command -v ffmpeg || echo "MISSING: ffmpeg"

Install Missing Dependencies

yt-dlp:

# macOS
brew install yt-dlp

# Linux
sudo apt update && sudo apt install -y yt-dlp

# pip (universal)
pip3 install yt-dlp

ffmpeg:

# macOS
brew install ffmpeg

# Linux
sudo apt update && sudo apt install -y ffmpeg

Input Requirements

• Required: YouTube URL
• Optional (ask user if not specified for long videos >30 min):
• Number of clips (default: 3-5 based on video length)
• Topic focus keywords
• Min/max clip duration (default: 30s-180s)

Available Python Scripts

The skill includes helper scripts in the .claude/skills/get-y2b-clips/ directory:

| Script | Purpose | |--------|---------| | parse_vtt.py | Parse VTT subtitles into segments.json (cleans HTML entities) | | extract_transcript.py | Extract transcript with auto sentence boundary detection | | download_clip.py | Download video clip with retry logic and progress reporting | | burn_subtitles.py | Generate subtitled video with hardcoded captions | | utils.py | Shared utilities for timestamp parsing |

Transcript Curation (CRITICAL)

Auto-generated YouTube captions lack punctuation. The transcript must be manually curated to ensure:

1. Complete starting sentence: Must begin with a coherent thought, not mid-sentence
2. Complete ending sentence: Must end with a complete thought, not cut off
3. Proper formatting: Sentences on separate lines with blank lines between
4. Punctuation added: Add periods, commas, question marks as needed

Workflow: Transcript → Video (Not the reverse!)

1. Identify target timestamps (where the insight is)
2. Run extract_transcript.py to get raw extraction + suggested video timestamps
3. MANUALLY CURATE the transcript:
   - Ensure first sentence is complete (may need to trim start)
   - Ensure last sentence is complete (may need to extend/trim end)
   - Add punctuation and formatting
   - Split into readable paragraphs
4. Use the VIDEO_START and VIDEO_END from script output
   - Video should start ~2s BEFORE first word of transcript
   - Video should end ~2s AFTER last word of transcript
5. Download video using those curated timestamps

Example Curation:

Raw extraction (bad):

Successful why do you think we're learned and it turns out that many or most of the people in The Venture business...

Curated (good):

It turns out that many or most of the people in the venture business historically would answer that question by telling you they finance the best and brightest, the greatest managers.

We do not.

We have always focused on the market - the size of the market, the dynamics of the market, the nature of the competition.

Because our objective always was to build big companies.

If you don't attack a big market, it's highly unlikely you're ever going to build a big company.

Using extract_transcript.py

# Run the script to get raw extraction and video timestamps
python3 extract_transcript.py \
    --start 00:04:00 \        # Target start (where insight begins)
    --end 00:05:08 \          # Target end (where insight ends)
    --title "Clip Title" \
    --source "Video Title" \
    --output "clip_folder/Transcript.txt" \
    --json                     # Also outputs JSON with timestamps

# Output will show:
#   VIDEO_START=00:03:58      |\\' '-')
VIDEO_DURATION=$(yt-dlp --print "%(duration)s" "$VIDEO_URL")
VIDEO_ID=$(yt-dlp --print "%(id)s" "$VIDEO_URL")

echo "Video: $VIDEO_TITLE"
echo "Duration: $((VIDEO_DURATION / 60)) minutes"

# Create output folder
TIMESTAMP=$(date +"%Y-%m-%d_%H-%M-%S")
SLUG=$(echo "$VIDEO_TITLE" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | cut -c1-50)
OUTPUT_DIR="./clips/${TIMESTAMP}_${SLUG}"
mkdir -p "$OUTPUT_DIR"

echo "Output folder: $OUTPUT_DIR"

Phase 2: Get Transcript with Exact Timestamps

Priority order: Manual subtitles → Auto-generated → Whisper

cd "$OUTPUT_DIR"

# Check available subtitles
yt-dlp --list-subs "$VIDEO_URL"

# Try manual subtitles first
if yt-dlp --write-sub --sub-langs "en" --skip-download -o "transcript" "$VIDEO_URL" 2>/dev/null; then
    echo "Manual subtitles downloaded"
elif yt-dlp --write-auto-sub --sub-langs "en" --skip-download -o "transcript" "$VIDEO_URL" 2>/dev/null; then
    echo "Auto-generated subtitles downloaded"
else
    echo "No subtitles available - Whisper transcription required"
    # Ask user before proceeding with Whisper (downloads audio)
fi

Parse VTT using the skill's Python script:

# Parse VTT file into segments.json and full_transcript.txt
python3 .claude/skills/get-y2b-clips/parse_vtt.py transcript.en.vtt

# This creates:
#   - segments.json (for precise timestamp lookup)
#   - full_transcript.txt (for reading/analysis)

Alternative inline Python (if script not available):

import re
import json

def parse_vtt(filename):
    with open(filename, 'r', encoding='utf-8') as f:
        content = f.read()

    lines = content.split('\n')
    segments = []
    current_start = None
    current_end = None
    seen_text = set()

    for line in lines:
        line = line.strip()

        # Check if this is a timestamp line
        time_match = re.match(r'^(\d{2}:\d{2}:\d{2})\.(\d{3}) --> (\d{2}:\d{2}:\d{2})\.(\d{3})', line)
        if time_match:
            current_start = f"{time_match.group(1)}.{time_match.group(2)}"
            current_end = f"{time_match.group(3)}.{time_match.group(4)}"
            continue

        # Skip metadata and empty lines
        if not line or line.startswith('WEBVTT') or line.startswith('Kind:') or line.startswith('Language:'):
            continue

        # Skip lines with tags (word-by-word breakdowns)
        if '= transcript_start and seg['start']  1 else s.upper()
        formatted_sentences.append(s)

# Write clean, formatted transcript
with open('Clip_Title Transcript.txt', 'w') as f:
    f.write(f"Clip Title - Transcript\n")
    f.write(f"Source: Video Title\n")
    f.write(f"Video: {video_start[:8]} - {video_end[:8]}\n\n---\n\n")
    f.write('\n\n'.join(formatted_sentences))  # Each sentence on new line

Step 3: Download Video using EXACT timestamps

CRITICAL: Use the same timestamps from the transcript extraction.

START_TIME="00:12:06"  # Must match transcript start
END_TIME="00:14:05"    # Must match transcript end
CLIP_TITLE="Clip Title"
SAFE_TITLE=$(echo "$CLIP_TITLE" | tr '/:?*"<>|\\' '-')

# Create clip folder
CLIP_DIR="$OUTPUT_DIR/01_$(echo "$SAFE_TITLE" | tr '[:upper:]' '[:lower:]' | tr ' ' '_' | cut -c1-40)"
mkdir -p "$CLIP_DIR"

# Download video clip with EXACT timestamps
yt-dlp -f 'bestvideo[height 2 hours    | 5-7               | 90-180 seconds      |

## Interactive Flow (Long Videos)

For videos > 30 minutes without user guidance, ask:

I found a [X] minute video. How would you like to proceed?

A) Extract top 5 clips automatically (recommended) B) Focus on specific topics - please specify keywords C) Extract more clips - specify how many D) Let me scan the transcript first and suggest topics

## Error Handling

| Issue | Solution |
|-------|----------|
| No subtitles | Offer Whisper with audio size warning |
| ffmpeg missing | Provide install command |
| Clip download fails | Retry with simpler format `-f best` |
| Private video | Inform user, cannot proceed |
| Very short video | Suggest 1 clip or full download |
| Timestamp mismatch | Re-verify against segments.json |

## Output File Naming

- Folder: `YYYY-MM-DD_HH-MM-SS_/`
- Clips: `NN_/`
- Files per clip:
  - ` metadata.json` - Complete clip info (transcript, timestamps, why selected)
  - ` Transcript.txt` - Human-readable transcript with formatting
  - ` Video.mp4` - Raw video clip
  - ` Subtitled.mp4` - Video with burned-in captions (for social media)

### Per-Clip metadata.json Structure

Each clip folder contains a `metadata.json` with all information combined:

```json
{
  "title": "This Is NOT a Bubble",
  "source_video": "Bitcoin Fear Hits All-Time High",
  "video_url": "https://www.youtube.com/watch?v=VIDEO_ID&t=1896s",
  "video_start": "00:31:36.000",
  "video_end": "00:32:54.000",
  "transcript_start": "00:31:38.350",
  "duration_seconds": 78,
  "word_count": 218,
  "selection_rationale": {
    "controversy": {
      "score": 10,
      "reason": "Directly calls out Michael Burr and Jeff Gundlach as wrong about AI bubble"
    },
    "insight": {
      "score": 9,
      "reason": "Data-driven comparison: NDX 800% vs 100%, Nvidia $60B quarterly revenue"
    },
    "engagement": {
      "score": 9,
      "reason": "Strong emotional conviction, direct callout of famous contrarians"
    },
    "relevance": {
      "score": 9,
      "reason": "Directly addresses fear sentiment from video title"
    }
  },
  "actionable_takeaway": "Don't conflate extreme fear with bubble conditions. Look at earnings growth and historical comparisons.",
  "transcript": "Full transcript text here (always last key for readability)..."
}

Notes:

• video_url: Direct link to the clip's start time in the original video (uses &t=XXXs parameter)
• transcript_start: Used when video has a buffer before speech starts (ensures subtitle sync)

Example Session

User: Extract the best clips from https://www.youtube.com/watch?v=abc123

Claude:

1. Checks dependencies (yt-dlp, ffmpeg)
2. Gets video info: "AI Future Podcast - 1:45:00"
3. Downloads transcript with exact timestamps
4. Analyzes transcript, identifies top segments
5. For each clip:

• Creates metadata.json (transcript + selection rationale + scores)
• Creates Transcript.txt (human-readable version)
• Downloads video using exact timestamps
• Creates subtitled version with burned-in captions

1. Returns summary with folder location

User: Get 3 clips about "startup funding" from https://youtube.com/watch?v=xyz789

Claude:

1. Same setup
2. Filters transcript for "startup", "funding", "invest", "raise" keywords
3. Scores segments with topic_match weighted higher
4. For each of 3 clips: metadata.json → Transcript.txt → Video → Subtitled Video
5. Returns summary

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: DidierRLopes
• Source: DidierRLopes/get-y2b-clips
• License: MIT

Install and usage instructions live in the source repository linked above.