Youtube Watch Later Gist Summaries

> Project: YouTube Watch Later Skill, a public GitHub Gist published by Eleanor Berger (intellectronica). The skill was written by her Hermes agent, which the frontmatter credits as the author. > > License: MIT, as declared in the skill's frontmatter. Full license text is in [LICENSE](LICENSE) alongside this file. > > Snapshot: Frozen copy of the gist as of 2026-05-22. The maintained version lives upstream and may have evolved since this snapshot.

YouTube Watch Later Gist Summaries

Overview

Use this skill to produce shareable summary links for all videos currently in a user's YouTube Watch Later playlist. The output is a concise list of Channel — Title — https://gists.sh// entries, with one secret GitHub gist per video summary.

This skill is intentionally browser-tool agnostic. Use whichever browser-control tool is available in the current environment, but operate the user's already logged-in browser/session where possible. Do not assume a particular browser automation package, profile path, or Chrome debugging port unless the environment explicitly provides one.

Hard Boundaries

• Do not add videos to Watch Later.
• Do not remove videos from Watch Later.
• Do not mutate unrelated browser, YouTube, GitHub, or Hermes configuration.
• Do not make public gists. gh gist create is secret by default on current GitHub CLI versions; avoid --public.
• Do not paste full transcripts into chat, logs, process titles, or gist descriptions.
• Do not rely on another YouTube transcript skill being installed; transcript extraction instructions are included below.

Prerequisites

• A browser-control tool that can inspect the user's authenticated YouTube session.
• The user is logged in to YouTube in that browser session.
• gh is installed and authenticated to the GitHub account that should own the gists.
• Network access to YouTube and GitHub.
• A way to fetch transcripts, preferably Python with youtube-transcript-api; fallback options are documented below.

Check prerequisites before doing expensive work:

gh auth status
python3 - `.
- `title` exactly as YouTube displays it, trimmed.
- `channel` if shown; otherwise use `Unknown channel` and continue.
- Optional useful fields: duration, playlist index, unavailable/private/deleted status.

De-duplicate by `video_id` while preserving playlist order. If an item is unavailable/private/deleted and no transcript can be fetched, keep it in the final report with `Summary: unavailable` rather than silently dropping it.

Browser extraction can be done by accessibility snapshots, page DOM evaluation, or exported page data. Prefer structured DOM data when available. A generic DOM strategy is:

```javascript
[...document.querySelectorAll('ytd-playlist-video-renderer, ytd-playlist-panel-video-renderer')]
  .map((el, index) => {
    const link = el.querySelector('a#video-title, a.yt-simple-endpoint[href*="watch"]');
    const href = link?.href || '';
    const url = new URL(href, location.href);
    const video_id = url.searchParams.get('v');
    const title = (link?.textContent || link?.getAttribute('title') || '').trim();
    const channel = (el.querySelector('ytd-channel-name a, #byline a, .ytd-channel-name')?.textContent || '').trim();
    const duration = (el.querySelector('ytd-thumbnail-overlay-time-status-renderer, .ytd-thumbnail-overlay-time-status-renderer')?.textContent || '').trim();
    return video_id ? {index: index + 1, video_id, url: `https://www.youtube.com/watch?v=${video_id}`, title, channel, duration} : null;
  })
  .filter(Boolean)

Treat this as a starting point only; YouTube DOM changes often. Verify the extracted count and spot-check the first and last few titles in the browser.

3. Fetch each transcript

Try transcript sources in this order. Save transcripts only in temporary working files unless the user asked for a cache.

Primary: youtube-transcript-api

Use an isolated Python command. This example tries manually supplied captions first, then generated captions, and prefers English/English-translated text where available:

uv run --with youtube-transcript-api python - "$VIDEO_ID" > "$TRANSCRIPT_FILE" 

Channel: 
YouTube: https://www.youtube.com/watch?v=

## TL;DR

## Key points
- 
- 
- 

## Notable details
- 

## Why it might matter

Summarise from the transcript. If the transcript is very long, chunk it and combine chunk notes into the final summary. Preserve uncertainty: if the transcript is noisy, partial, auto-translated, or missing parts, say so in the summary.

5. Create one secret gist per ready summary

For each summary file:

gh gist create --desc "Summary: " --filename ".md" - /`.

Derive `` from `gh api user --jq .login` or from the returned gist URL. For a returned URL like `https://gist.github.com/octocat/abc123`, the `gists.sh` URL is `https://gists.sh/octocat/abc123`.

Verify each gist before reporting it:

```bash
gh api "gists/$GIST_ID" --jq '{id, public, description, files: (.files | keys)}'

Expected: public is false, at least one Markdown file exists, and the description begins with Summary:.

6. Return the final list

Return the list in playlist order. Use a compact, copyable format:

1.  — 
   Summary: https://gists.sh//
   YouTube: https://www.youtube.com/watch?v=

2.  — 
   Summary: unavailable — 
   YouTube: https://www.youtube.com/watch?v=

Include a brief status line: total videos found, summaries created, gists verified, failures. Do not include full transcript text.

Suggested Working Manifest

When implementing this workflow, keep a machine-readable manifest in the workspace so the run can resume safely after failures:

playlist_url: https://www.youtube.com/playlist?list=WL
created_at: ""
videos:
  - index: 1
    video_id: ""
    title: ""
    channel: ""
    youtube_url: "https://www.youtube.com/watch?v="
    transcript_file: "transcripts/.txt"
    transcript_status: ready
    summary_file: "summaries/.md"
    summary_status: ready
    gist_id: ""
    gist_url: "https://gist.github.com//"
    gists_sh_url: "https://gists.sh//"
    gist_public: false

This manifest is an implementation aid, not a user-facing deliverable. Do not store credentials or raw cookies in it.

Common Pitfalls

1. Assuming a fresh headless browser is logged in. Use the user's logged-in browser/session where available; otherwise ask for an authenticated session.
2. Hard-coding a browser tool. The workflow should work with any browser-control surface that can navigate, scroll, inspect DOM, and verify state.
3. Using gh gist create --public by accident. Public gists are wrong for this task.
4. Depending on another transcript skill. This skill must remain self-contained enough to fetch transcripts directly.
5. Dropping unavailable/private videos from the report. Keep playlist order and report concise failure reasons.
6. Creating duplicate gists after a retry. If a manifest from the same run exists, reuse recorded verified gist IDs rather than creating new ones.
7. Logging too much. Transcripts can be long and may contain sensitive user-watch context; keep logs minimal.

Verification Checklist

• [ ] The browser is authenticated to YouTube and https://www.youtube.com/playlist?list=WL loads the user's Watch Later playlist.
• [ ] Scrolling reached the end and extracted videos are de-duplicated by video_id.
• [ ] First and last extracted playlist items were spot-checked against the browser.
• [ ] Every available video has either a transcript-backed English summary or a concise failure reason.
• [ ] Exactly one secret gist was created or reused for each ready summary.
• [ ] gh api gists/ confirms public:false for every reported gist.
• [ ] Final output includes channel, title, gists.sh summary link or failure reason, and YouTube URL for every playlist item.

Source & license

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

• Author: hugobowne
• Source: hugobowne/show-us-your-agent-skills
• License: MIT
• Homepage: https://hugobowne.github.io/show-us-your-agent-skills/

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