Claude Video skill
The /watch skill turns a link or file into frames and captions, or with a Gemini key hands the whole video to Google for the agent to answer from
- 19,071 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- The skill runs installers: Homebrew on macOS, uv, Python 3.12 and WhisperX packages, and a hook runs a settings check at every session start
- In Gemini mode the whole clip, a local file included, is uploaded to Google, and cloud recognition sends audio to Groq or OpenAI
- Gemini, Groq and OpenAI keys sit in ~/.config/watch/.env, and on explicit request the skill reads browser cookies or a cookie file
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/claude-videoDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- The skill runs installers: Homebrew on macOS, uv, Python 3.12 and WhisperX packages, and a hook runs a settings check at every session start
- In Gemini mode the whole clip, a local file included, is uploaded to Google, and cloud recognition sends audio to Groq or OpenAI
- Gemini, Groq and OpenAI keys sit in ~/.config/watch/.env, and on explicit request the skill reads browser cookies or a cookie file
This is third-party code. Review the repository files before installing.
What it does
Claude Video installs the /watch skill, which shows an agent a video from a link or a local file. There are two modes. If a GEMINI_API_KEY is found, Google's model watches the video: YouTube links go to Google directly, other addresses are downloaded by yt-dlp, and downloaded and local files are uploaded to the Files API and deleted after the answer. In the report the agent gets Gemini's answer to your question with timestamps and relays it. Without a key the local mode runs. yt-dlp downloads the clip, ffmpeg cuts it into frames, the skill drops near-identical frames using a 16 by 16 pixel thumbnail, and the agent reads each frame together with the text. The text comes from built-in captions, or, when there are none, from a fallback speech recognizer: local WhisperX or cloud Groq and OpenAI. Four detail levels set how deep the look goes: transcript only, up to 50 frames by keyframes, up to 100 frames by scene changes, and an uncapped set. On first run the skill asks how to watch videos, which detail level to keep by default and what to transcribe speech with, and saves the answers in ~/.config/watch/.env. A clip fragment is set with --start and --end, and individual moments the speaker points to with a phrase like look here are pulled out with --timestamps.
Who it is for. For people who work with tutorials, call recordings and reviews and want Claude Code or Codex to answer from a video's content with minute marks.
Good fit when
- You need a summary of a YouTube tutorial with timestamps for key moments
- You must find the minute in a call recording or demo where a specific screen or setting is shown
- The agent has to read on-screen text from a presentation or code from a video: frame width is raised to 1024 for that
- A clip has no captions but speech must be transcribed locally with no audio sent to the cloud
- You need to analyze a single segment of a long recording by setting --start and --end
Not a fit when
- You work in Claude Chat or Cowork: the skill is not supported there, and in Cowork's cloud environment the local mode cannot download most links
- The machine cannot have Python 3.10, FFmpeg and a current yt-dlp: the skill does not bundle them
- The video is private or must not go to a third party while a Gemini key is configured: in that mode the file goes to Google, such a clip needs --engine local
- You need editing, cutting or generating video: the skill only shows video to the agent, and video-use handles editing
Example request
Watch this YouTube video, tell me at which minute the author shows the hooks setup, and retell the stepsLimitations
The skill works in Claude Code: in the desktop app's Code tab, in VS Code and in a terminal, as well as in Codex and other local agents. Claude Chat and Cowork are not supported. Claude Code on the web has its own environment, and the interactive /plugin installer is unavailable there.
The skill itself bundles no programs. It needs Python 3.10 or newer, FFmpeg and ffprobe and a current yt-dlp, and for YouTube also a JavaScript runtime such as Deno. On macOS the skill installs what is missing through Homebrew; on other systems it prints commands.
Local WhisperX recognition needs about 1.5 GB of download, at least 3 GB of free disk and 8 GB of memory. Only the install on Apple Silicon with macOS was verified: the author calls Intel, Linux and Windows untested, and CUDA is configurable but was not tested. For non-English speech without a language hint the small model can make mistakes.
The skill is most accurate on clips shorter than 10 minutes. On long recordings frames are sparse, scene detection does not catch every event, and the thumbnail comparison can miss a small code edit: then --no-dedup is turned on.
MIT license.
How to disable. Remove the plugin with /plugin in Claude Code, or the skill with the same tool you installed it with. Settings and keys stay in ~/.config/watch/.env, the WhisperX environment in ~/.cache/watch/whisperx-venv and the models in ~/.cache/huggingface and ~/.cache/torch/hub: delete them by hand, reinstalling the skill leaves them alone.
FAQ
Which should I choose on first run: Gemini or the local mode?
The setup wizard recommends Gemini: it needs a free key from Google AI Studio, and the default model is set by the WATCH_GEMINI_MODEL variable. The local mode needs no key and sends nothing to Google, but the agent itself reads the frames and the text. You can pick the mode for a single run with the --engine flag.
How do I watch a video that requires an account login?
Pass --cookies with a cookie file or --cookies-from-browser with a browser name such as firefox. The skill does not search browser sessions on its own. It treats the cookie file as writable: yt-dlp may update it.
How many frames will the agent get?
efficient gives up to 50 frames, balanced up to 100, and token-burner has no cap and warns above 250 frames. The cap is changed with --max-frames; frame width is 512 pixels by default and is raised with --resolution 1024 for on-screen text.
How do Groq, OpenAI and WhisperX differ for speech recognition?
WhisperX runs on your computer with no key, Groq uses the cloud whisper-large-v3 model and OpenAI uses whisper-1; both need keys. The cloud services get only audio, split into pieces of up to 24,000,000 bytes. Captions from the video are always read first.
What does the hook do at session start?
The plugin registers a SessionStart hook that runs the quick setup.py --check with a 5-second limit. If dependencies or settings are missing, a hint to call the skill appears in the session. The check touches neither Torch nor the network.
How do I show the agent a moment the speaker points to?
The agent reads the transcript, finds phrases like look here and reruns the skill with --timestamps 4:32,7:10. These frames take their share of the budget before the rest. If only captions were fetched on the first pass, the clip is downloaded again for this.
Discussion
No questions or reviews yet.
Related
SkillsA Claude Code skill that downloads a YouTube video, splits it into semantic chapters, cuts chosen clips, translates subtitles and burns bilingual ones in
Claude Real Video
claude-real-video
A skill that lets Claude watch a video: it pulls scene-aware, deduplicated frames and a speech transcript through whisper from a link or file
Claude Video Vision
claude-video-vision
An MCP server and Claude Code plugin that let the agent watch video: frames via ffmpeg and audio transcription via Gemini, local Whisper or OpenAI
yt-fts downloads subtitles of YouTube channels and playlists into SQLite and finds phrases with links to the exact second, plus semantic search and chat
YouTube Skills
YouTube Skills for AI Agents
A set of skills that gives an agent YouTube transcripts, video and channel search, and playlist extraction over one API
A skill that pulls highlights from a long video: download, transcript, segmentation, analysis and clips with titles
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| Claude Video (this entry) | no | 19,071 | ||
| Claude Video Vision | no | not required | 1,407 | an MCP server and plugin: frames via ffmpeg, audio via Gemini, local Whisper or OpenAI, six tools |
| Claude Real Video | no | 2,255 | a skill installed through pip with speech recognition via whisper | |
| watch-skill | no | not required | 514 | an MCP server and skill that turns video, audio and screen recordings into timestamped evidence, version 0.1.x |
README in short
The repository has a detailed guide with install tables for Claude Desktop, VS Code, the terminal, Codex and other local agents, sections on mode choice, speech recognition, detail levels, captions and cookie login, and a troubleshooting table. Besides the skill it holds plugin manifests for Claude Code and Codex, a settings-check hook, a changelog, an AGENTS.md reference for agents, the scripts watch.py, download.py, frames.py, gemini.py and setup.py, and sixteen test files run in GitHub Actions.
README badge
Original SKILL.md
---
name: watch
description: Watch a video (URL or local path). Downloads with yt-dlp, extracts auto-scaled frames with ffmpeg, pulls the transcript from captions (or local WhisperX / cloud Whisper fallback), and hands the result to the agent so it can answer questions about what's in the video. With a Gemini API key, Google's agentic video model watches the full video instead.
license: MIT
allowed-tools: Bash, Read, AskUserQuestion
metadata:
version: "0.3.2"
---
# /watch
Run the bundled Python script. With the **gemini** engine (a `GEMINI_API_KEY` is configured) Google's video model watches the video and the report carries its timestamped answer for you to relay. With the **local** engine the script produces timestamped frames and a transcript; view the frames and answer from that evidence. Native captions come first; the chosen local or cloud backend is only a fallback. Transcript-only evidence cannot establish visual facts.
## Resolve the skill and interpreter
`SKILL_DIR` is the absolute directory containing this SKILL.md; `scripts/` sits beside it.
Commands below use `python3` for macOS/Linux. On Windows, verify a working Python 3.10+ with `python --version` or `py -3 --version` and use that interpreter. `python3` is not always a Store alias; inspect the actual result. In PowerShell use `$SKILL_DIR` rather than Bash variable syntax, for example:
```powershell
python "$SKILL_DIR/scripts/setup.py" --json
```
Use the host's available shell, image viewer, and question tool. `AskUserQuestion` and Bash are examples, not requirements for every host.
## First run and setup
On the first invocation in a session:
```bash
python3 "${SKILL_DIR}/scripts/setup.py" --json
```
- `can_proceed` depends on base binaries for the local engine, not optional credentials. If it is false, run `setup.py` and confirm the binaries become available. macOS uses Homebrew; other systems get package commands. Do not use sudo automatically. With the Gemini engine (`engine` is `gemini`, `binaries_required` false), missing `ffmpeg`/`yt-dlp` do not block YouTube URLs but are still needed for other URLs and for `--engine local`; mention `missing_binaries` only when that matters.
- If `first_run` is false, proceed without announcing successful setup or asking preferences again. Existing installations without a backend setting retain `auto` (Groq key first, then OpenAI).
- If `first_run` is true, ask the engine question first, then (local engine only) the two choices below it. The wizard does not inspect RAM, disk, CPU, browser sessions, or other machine state; the user decides from the stated requirements.
**Question 1 — "How should watch view videos?"**
- `gemini` (recommended) — Google's Gemini model watches the whole video, including audio, and answers directly. Needs a free key from https://aistudio.google.com/apikey. YouTube URLs are sent to Google; local or downloaded videos are uploaded to Google, then deleted after the answer.
- `local` — frames + transcript extracted on this machine and read by you. No key needed.
If `gemini`, run:
```bash