Skip to content
cs – Přepnout do češtiny

source-to-skill

One command turns a lecture, a podcast, a paper, a book, an article or a repository into a skill your coding agent loads on demand — and every answer links back to where it came from, down to the half-minute in a recording.

Solo — concept, architecture, Python, docs2026Open source (MIT) · v0.6.0 · Claude Code plugin
Python 3.10+Agent SkillsClaude Code pluginYouTubePodcastsLocal WhisperarXivEPUBGitHubNo API keys

source-to-skill points a coding agent at something worth knowing and hands back a skill it can load on demand. A two-hour lecture, a podcast feed, “Attention Is All You Need”, an EPUB, a blog post, the Flask repository — one command each. What comes out is a folder of structured Markdown the agent reads when a question calls for it, not a transcript pasted into the context window.

The split is the whole design. A deterministic Python extractor normalizes every source type to one contract — plain text plus metadata — and the agent does the distilling, following instructions that ship with the skill. The tool never calls a model API of its own: a recording without captions is transcribed on your machine with Whisper, and the model doing the distilling is the one you're already talking to. Answers from a recording deep-link to the second (&t=), papers keep methods, findings and limitations apart, a playlist or a podcast show becomes a course, and several sources become one skill that keeps a list of where they disagree.

11
kinds of source, from a lecture to a podcast feed
320
tests, all of them offline
1.7k
tokens up front for all of Pro Git — out of 186k
0
API keys — Whisper runs locally, the rest is your agent

the problem

A coding agent is excellent at what it already knows and helpless in front of the two-hour lecture you watched last week. The obvious fix — paste in the transcript — is the wrong shape twice over. It's big: a transcript of just 4 962 words is about 6 600 tokens of prose that pushes everything else out of the window. And it's narration, the format least like the answer you want.

What an agent can actually use is structure: the frameworks, the decision rules, the concrete numbers, and a way back to the original when an answer needs checking. That's a different artefact from a summary, and it's exactly what the Agent Skills format is for — instructions the agent loads when the situation calls for them and ignores the rest of the time.

a deterministic half and a fuzzy half

Extraction and distillation are different problems, and the tool refuses to blur them. extract.py detects the source type from the URL or file, runs the matching parser, and writes three things to a work directory: full_text.txt, metadata.json and source.json, the manifest that later lets a skill be refreshed. A recording with no captions is transcribed here too, locally, by whichever Whisper backend is installed. That half is ordinary Python — testable, repeatable, and it either works or tells you why it didn't.

Distillation is the half that needs judgement, so it stays with the agent. SKILL.md tells it what a good skill for this source type looks like; the agent reads the extracted text, confirms the token cost with you first, writes the files and checks the result with validate_skill.py. There's no second model sitting on a server somewhere, because the model is already in the room.

So the 320 tests cover the part that can be tested and don't pretend to cover the part that can't — and every one of them runs without a network connection.

one contract, seven parsers

Five steps left to right: a source (video, podcast, paper, book, article or repo), extract.py — deterministic Python with no LLM and no API keys, the contract of full_text.txt and metadata.json, your agent confirming the token cost and distilling by template, and the skill: a ~4k-token SKILL.md with segments, lessons, chapters, findings and a cheatsheet on demand
the whole pipeline — from the project's README

what comes out

A two-hour lecture with twelve chapters becomes twelve segment files. SKILL.md carries the core ideas and an index of the segments and is capped at about 4 000 tokens — in the examples gallery it lands between 1.1k and 2.0k — and it's the only part the agent pays for by default. A segment file is read only when a question actually lands in its chapter, and cheatsheet.md holds the actionable steps and decision rules, with none of the narration.

Papers keep the shape a paper has — methods.md, findings.md, limitations.md, glossary.md, citations.md — because folding the limitations into a summary is how a paper ends up cited for something it explicitly said it couldn't show. Books keep their chapters. A playlist, a channel or a podcast show becomes a course: a lesson index, one file per video or episode and one cheatsheet across the whole set.

a real run, not a mock-up — one file per chapter, only the index loaded up front

the answer points to the second it came from

Every segment file opens with a link back to the source at the moment that segment starts. Ask about masking and the answer arrives with &t=668s attached — eleven minutes and eight seconds in, right where the lecturer says it.

Since v0.5 a long chapter is no longer one link: the transcript carries an inline marker every 30 seconds, so a claim links to within half a minute of where it was said, for about 3% more tokens. Podcasts and audio files get the same, with #t= where the origin can seek.

This is what makes the skill trustworthy rather than merely convenient. A distillation is a claim about what the source said, and a claim you can't check in one click is one you end up taking on faith. Papers and articles do the same with their original URL; a repository skill points back to the documentation file it came from.

A generated segment file opening with a YouTube link whose &t=668s is highlighted, followed by the distilled explanation of masking
the distilled note, and the eleven-minute mark it answers to

eleven sources, one command

  • YouTube video — captions via yt-dlp, manual first with auto-generated as a fallback, in any language; segmented by the video's own chapters. No captions at all, and a local Whisper backend, if installed, transcribes it instead.
  • Playlist and channel — a playlist becomes a course; a channel gives its latest 20 uploads (--limit N). A video without a transcript is skipped with a warning, and a run that hits YouTube's rate limit says so instead of blaming missing captions.
  • Podcast episode, podcast show, any recording — an Apple Podcasts link, an RSS feed (its latest five episodes as one course), a direct .mp3, a local meeting recording, or anything else yt-dlp can download, transcribed on your machine with mlx-whisper or faster-whisper. Spotify is DRM-protected and stays out.
  • Paper — PyMuPDF with academic section detection; an arXiv URL also pulls title, authors and year from the arXiv API, and references split into one entry each.
  • Book — EPUB with nothing but the standard library, code blocks keeping their indentation and tables kept as tables. A PDF book takes its chapters from the document outline.
  • Web article — readable-content extraction, also standard library only: it prefers <article>, drops navigation, footers and scripts, and finds the byline in JSON-LD when the page hides it.
  • GitHub repository — README and docs/ from a single tarball download, no clone, in Markdown, MDX or reStructuredText, ordered the way the docs' own table of contents orders them.
Eight cards, source to what your agent gets: YouTube video, playlist or channel, podcast or audio, paper, book, web article, GitHub repo, and several sources combined into one topic skill that records disagreements
what each kind of source turns into — from the project's README

several sources, and where they disagree

Pass several sources and you get one topic skill. Every idea carries the sources behind it ([S1], [S2]), and a disagreements.md records where they contradict each other or use different numbers or definitions — side by side, never averaged into one claim. Averaging is what a summary does by default, and it's exactly how a confident wrong answer gets made.

The example in the gallery is “Attention Is All You Need”, 3Blue1Brown's video and Jay Alammar's Illustrated Transformer. They agree on the formula and disagree on things that matter: whether positional encodings are learned or fixed, how sine and cosine are laid out in the vector — and the paper disagrees with itself, quoting 41.8 BLEU in the abstract and 41.0 in the text.

A skill also remembers where it came from. /source-to-skill update re-extracts the playlist or channel, diffs it against the saved source.json and generates only the new lessons.

Terminal: one command with a paper, a video and an article produces how-transformers-work with SKILL.md, cheatsheet.md, disagreements.md and sources/; cat disagreements.md shows the sources split on whether positional encodings are learned or fixed, and the paper's two BLEU numbers
three sources, one skill — excerpted from the gallery example

engineering decisions

  • No API keys, anywhere. Transcription runs on your machine and the distillation runs on the agent you're already paying for. Ask for a key and most people never get past step one.
  • The standard library wherever it's enough. EPUB books, web articles and GitHub repos need nothing installed. yt-dlp, PyMuPDF and a Whisper backend are required only by the sources that genuinely need them, and --check tells you which ones you're missing — and when your yt-dlp is old enough that YouTube will start refusing it.
  • A tarball, not a clone. Reading a repository's docs doesn't need its history, and one download beats a clone that fails on a large repo over a slow connection.
  • Confirm the cost before spending it. The extractor reports the word count and a token estimate, and the agent asks before distilling. A two-hour lecture isn't free, and the tool doesn't pretend otherwise.
  • The gallery is made by the tool. Every skill in examples/ — a talk, a course, a paper, Pro Git, an essay, Flask and a three-source topic — was generated from the linked source, and CI validates all of them, so you can read the output before installing anything.
  • The repo is its own first skill. skills/source-to-skill/ is self-contained and installs the same way as anything it produces — as a Claude Code plugin, or symlinked into whichever skills folder your agent reads. CI runs claude plugin validate --strict on the manifests.

status & what's next

v0.6.0, two months after v0.4. v0.5 added everything you listen to — podcasts, audio files, captionless videos — plus channels, topic skills, refresh, a CLI package and the examples gallery; v0.6 added whole podcast shows from RSS, tables in books and articles, and repository docs in the order their authors meant. Setup in Claude Code is still two lines, /plugin marketplace add michalstrnadel/source-to-skill and /plugin install source-to-skill@source-to-skill, and the same folder works in GitHub Copilot CLI or Amp, because Agent Skills is an open format.

What isn't done, stated plainly. The package is built and the release workflow is ready, but it isn't on PyPI yet, so the CLI installs with uvx straight from git for now. Scanned PDFs with no text layer still need OCR first, and a multi-speaker podcast has no speaker labels. And the biggest one: I haven't measured whether an agent answers better with a skill than without it. Evals are on the roadmap; until then the evidence is the gallery, which you can read in full.