video-to-skill
Turns a tutorial video into an agent skill: it reads the frames, not just the speech, and tests the steps in a sandbox
- 138 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- The utility downloads ffmpeg, yt-dlp and speech recognition models, and steps from someone else's video run on your computer inside an OS sandbox.
- The finished skill is written into every agent found, so text from a video becomes a lasting instruction for them.
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/video-to-skillDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The utility downloads ffmpeg, yt-dlp and speech recognition models, and steps from someone else's video run on your computer inside an OS sandbox.
- The finished skill is written into every agent found, so text from a video becomes a lasting instruction for them.
This is third-party code. Review the repository files before installing.
What it does
video-to-skill teaches an agent what a video shows. Given a YouTube link or a file, the `/video-to-skill` command listens to the narration, reads the screen, writes the steps, runs them and installs the result as a ready skill. Each step cites its time in the video as `[t=MM:SS]` and keeps the frame as evidence. Commands are taken from the screen rather than from speech: in the author's example the speech model heard 'some' while the frame showed the formula `=SUM(B3:B10)`. The local Rust utility `vts-extract` does the first pass: it downloads the video, splits it into frames, detects scene changes and transcribes speech with word timestamps. The agent inspects key frames selectively and writes steps tied to the source. Then a fresh sub-agent that has not seen the video runs the steps in an operating system sandbox with no network access. A passing step earns the skill a verification badge, and a failing step is repaired and tested again. The finished skill is installed for every agent found on the machine: one copy in `~/.agents/skills` and links from each agent folder. A second video about the same task extends the skill: matching steps gain confidence, and differences are kept as cited variants.
Who it is for. Developers and analysts whose process is recorded in a video lesson or screencast and who need to turn it quickly into a repeatable agent instruction.
Good fit when
- A screencast about configuring Vim, Excel or a CLI tool, and a skill that performs the same steps is needed.
- A team instruction recorded as a Loom video must become a procedure with each step verified.
- Two different lessons on one task should be merged into a single skill, keeping the disagreements between them.
- Exact commands and formulas from the screen are needed, while speech transcripts get names wrong.
- After watching a video the agent should learn the working process itself and apply it in other projects.
Not a fit when
- The video does not teach a procedure: a talk or vlog yields only a short report on why, with no steps.
- The clip shows fast physical actions whose details are lost between frames.
- The computer cannot take the download of ffmpeg, yt-dlp and speech recognition models.
Example request
/video-to-skill https://youtube.com/watch?v=... make a skill from this lesson on Vim basics and verify its steps.Limitations
It works best on screen recordings and lessons about apps and the command line. Some clicks in graphical programs cannot be checked by running them, and such steps are marked unverified. Verification runs in an OS sandbox: Seatbelt on macOS, bubblewrap on Linux, LPAC on Windows. Without a supported sandbox the steps are not executed and carry a mark that they were not verified. On first run the utility downloads ffmpeg, yt-dlp and the Whisper and Silero VAD models, shows the list beforehand and begins downloading only after the `--yes` flag.
How to disable. Delete the `video-to-skill` folder from the agent skills directory. Generated skills live in `~/.agents/skills` and are removed separately, and the downloaded utilities sit in the user program data.
FAQ
How do I install video-to-skill in Claude Code?
Run `npx skills@latest add brenoepics/video-to-skill` and open the installed `SKILL.md`: it leads to the `vts-extract` setup. No Homebrew, Python, account or API key is needed.
What leaves the computer for the model?
Only the frames the agent decides to look at. The video itself stays on the machine, and passwords and keys seen on screen are not copied into the skill.
What does the verified-by-execution badge mean?
A fresh sub-agent ran the skill steps in a sandbox with no network or file access, and the success criteria held. Steps that are unsafe to run are skipped, and the badge says how many.
What if the video is not about a procedure?
The skill returns a short report on why there are no steps. It does not invent instructions.
Where is the generated skill installed?
One copy lives in `~/.agents/skills`, and a link from each found agent folder points to it. The install plan is shown first, and writing begins after consent.
Discussion
No questions or reviews yet.
Related
SkillsTwo skills that pick other skills for a task: the hosted one fetches them from an index and collects feedback, the local one searches your SKILL.md folders
A meta-skill that turns a workflow into an agent skill: prior-art search, trigger evaluation and publication to GitHub
A CLI that runs your agent on tasks and revises its skills, keeping a change only when held-out tasks confirm the gain
Self-learning
self-learning-skills
A meta-skill that saves a hard-won working procedure as a new skill or rule, so the next session starts already knowing it
A meta-skill that distills methodologies from books, long videos, podcasts and courses into a set of ready-to-invoke agent skills
A skill that helps an agent author other skills to the agentskills.io spec: structure, metadata, progressive disclosure and validation
README in short
The documentation shows with examples why speech transcripts fail where a frame reads exactly and how verification by running differs from a plain retelling of a video. It ends with a comparison table against video summarizers and workflow recorders, installation details and speed notes.