I have a problem.

The list was a scroll I could never finish. A graveyard of good intentions.
And then one day — YouTube stopped letting me add more.

Watch Later has a hard limit.

• New saves silently fail — no error, no warning
• No export button. No CSV. No JSON. Nothing.
• No bulk delete. Remove videos one at a time, forever.
• YouTube Data API: Watch Later is a private playlist with no write access
• YouTube support: "we have no plans to address this"

Four phases. Fully automated.

• Scan — inventory Watch Later: count videos, flag unavailable ones
• Copy — batch 50 videos at a time to a target playlist
• Verify — confirm each video actually landed
• Delete — remove confirmed videos from Watch Later, free the slots

Chrome streams structured JSON back to the app — one event per video, per phase.
Interrupted runs resume exactly where they left off.

A local-first video library.

First → LLM categorization.   Second → watch queue.   Third → Python scraping.

Don't label.
Discover.

topics = [
  "AI & Machine Learning",
  "Mechanical Keyboards",
  "Embedded Systems",
  "Python & Dev Tools",
  "Indie Hacking",
  "macOS Development",
  "Security Research",
  "Hardware & Making",
  "Tech Podcasts",
  "Career & Productivity",
  # ... ~10 more
]

200 videos per prompt. Batched.

BATCH_SIZE = 200

for i in range(0, len(videos), BATCH_SIZE):
    batch = videos[i : i + BATCH_SIZE]

    prompt = f"""Topics:
{topics_as_numbered_list}

Assign each video to exactly one topic
by number. Return JSON.

Videos:
{format_batch(batch)}"""

    result = claude_haiku(prompt)
    apply_assignments(batch, result)

The model does
the surgery too.

• Split — break a broad topic into 3–8 subtopics automatically
• Rename — suggest better names based on sample video titles
• Reclassify — reassign a whole subtree with refined rules

Haiku classifies fast and cheap. Sonnet handles nuance.

400 creators.
100 API calls.

We follow 400+ creators. Polling all of them daily exhausts the quota before covering a quarter. Discovery had to work without API calls.

Four layers. Zero quota.

Two sources.
One merge.

def fetch_channel_videos(channel_id):
    scrape_vids = list(scrapetube.get_channel(channel_id))
    rss_vids    = fetch_rss(channel_id)

    seen = {}
    for v in rss_vids:                        # RSS wins on overlap
        seen[v["videoId"]] = {**v, "source": "rss"}
    for v in scrape_vids:                     # scrapetube fills gaps
        seen.setdefault(v["videoId"], {**v, "source": "scrape"})

    return list(seen.values())

Creator links.
A nightmare.

def get_channel_links(channel_id):
    try:
        # Path A: og:description meta tag
        # stable across layout changes
        links = extract_from_og_desc(channel_id)
        if links:
            return links

        # Path B: ytInitialData JSON blob
        # future-proofing
        links = extract_from_initial_data(
            channel_id
        )
        return links or []

    except Exception:
        return []  # never crash the caller

A venv, bundled.

let process = Process()
process.executableURL = venvPython
process.arguments = [
    scriptPath,
    "--channel-id", channelId
]

let stdout = Pipe()
let stderr = Pipe()
process.standardOutput = stdout
process.standardError  = stderr

try process.run()

// ⚠️  DO NOT waitUntilExit() yet
//     see next slide

The pipe buffer deadlock.

Script outputs >64KB. You wait for exit before reading. Process waits for you to read before it can exit. Neither side moves.

process.run()
process.waitUntilExit() // 💀

let data = stdout
  .fileHandleForReading
  .readDataToEndOfFile()

process.run()

// drain WHILE process runs
async let out = Task.detached {
  stdout.fileHandleForReading
        .readDataToEndOfFile()
}
async let err = Task.detached {
  stderr.fileHandleForReading
        .readDataToEndOfFile()
}
process.waitUntilExit()
let result = await out

Don't get rate-limited.

import time, random

class ScrapeRateLimiter:
    MIN_INTERVAL = 2.0   # seconds
    JITTER       = 1.5
    CHANNEL_COOL = 600   # 10 min
    GLOBAL_COOL  = 300   # 5 min

    def wait(self):
        elapsed = time.time() - self.last_req
        gap = (self.MIN_INTERVAL
               + random.uniform(0, self.JITTER))
        if elapsed < gap:
            time.sleep(gap - elapsed)
        self.last_req = time.time()

    def record_failure(self, channel_id):
        self.cooldowns[channel_id] = (
            time.time() + self.CHANNEL_COOL
        )

The stack.

Three takeaways.

• 1
  Scrape first, API second. For read-heavy discovery, scrapetube + RSS is faster, cheaper, and more reliable than the official YouTube API.
• 2
  Batch your LLM calls. 200 items per prompt vs. 1 per prompt is the difference between $0.15 and $150. Design for batching from day one.
• 3
  When there's no API, drive the browser. CDP is stable, powerful, and indistinguishable from a real user. It's not a hack — it's the same protocol DevTools uses.