# Claude Code Turns Any YouTube Channel Into a 1-Hour Course

> Point Claude Code at a YouTube channel. For $0 it writes a 1-hour course, the creator's method, a persona your agents can ask and a legit check. The code.

- Canonical: https://rodrigonask.com/claude-code-youtube-channel-into-course
- Published: 2026-10-28
- Author: Rodrigo Nask (https://rodrigonask.com/)

---

## Key takeaways

- Point the skill at any YouTube channel and it writes a 60-minute course of that creator's method, with exercises, a cheat sheet and a NotebookLM prompt.
- It reads captions only, through yt-dlp: no downloads, no paid APIs, no logins, $0 in tools.
- Every creator becomes five files: the course, the method, a persona, a legit check and a comparison with you, every claim linked to its video.
- The persona is written as "when X, do Y, because Z" rules, so any agent can check your plan the way that creator would.
- One line in your global CLAUDE.md points every chat at the archive.

YouTube Distiller is a Claude Code skill that turns a creator's public YouTube channel into a one-hour course, their method, a decision persona, a legit check and a comparison with you, every claim cited, and keeps them in an archive any later agent can consult.

You have watched 40 hours of some creator. You remember five ideas, and you could not say which video any of them came from. You are about to buy their course and you have no idea whether the results are real. And next month, building a funnel at midnight, you will wonder how they would do it, and the answer is somewhere in a video you watched in March.

So stop watching. Point Claude Code at the channel. For $0 in tools it reads the captions of the videos you pick and hands back the whole method as a 60-minute course: modules, exercises, a cheat sheet, and a prompt that turns it into audio. Next to the course you get the method itself, every point linked to its video, a persona your agents read when you ask "how would this creator do it?", and a legit check.

The legit check exists because spotting a fake guru by watching is hard. The good ones are great on camera, which is exactly what you measure when you watch.

The reference run: 29 videos, about 9 hours of talking, out comes a 7-module course that adds up to 60 minutes. This is the build, in seven steps, with the code.

> **Figure (animated on the web version):** Twenty-nine video tiles drop in. Nine hours of video become a 60-minute course, through captions only at zero dollars. Five files come out: LECTURE, METHOD, PERSONA, LEGIT and COMPARE, each with a small link back to its source video.
>
> A channel goes in. **A 60-minute course comes out**, with the method, the persona, the legit check and the comparison beside it, every claim pointing back to its video.

## Why watching more videos does not work

There are three normal ways to learn from a creator. All three fail for the same reason: nothing you end up with is something you can study in an hour or an agent can read.

**Watch and take notes.** Nine hours of video gives you the vibe, not the thresholds. You remember "test a lot of creatives", not "30 page views and zero leads means the creative goes". Your notes have no timestamps and live in a notebook your agents will never open.

**Ask a chatbot what the creator teaches.** It answers from whatever it absorbed about them. No link to the minute that said it, no idea what changed last year, no way to tell the method from the marketing.

**Buy the course.** Then you know what they sell, not whether it works. A course is the most polished version of their story, which makes it the worst place to check it.

The skill reads every word the creator said in the videos you pick, keeps the receipts, and writes files with links into a folder your agents can reach from any chat.

## What you are building

One skill folder and one archive.

1. **The skill.** A `SKILL.md` with two modes: distill a channel, and ask the archive. Seven small Python scripts that list the channel, pick videos, pull captions, batch them and render the report. Six briefs, one per kind of agent.
2. **A creator folder per person.** Captions as text, one note per video, theme syntheses, and the five files: `LECTURE.md`, `METHOD.md`, `PERSONA.md`, `LEGIT.md` and `COMPARE-<target>.md`, plus a `REPORT.html` that links all five as plain white pages.
3. **The archive index.** One `INDEX.md` at the root with a row per creator: what to ask them about, and their legit verdict.

The whole run, as the README draws it:

```text
channel  ->  enumerate.py  ->  pick.py (best or latest N)  ->  fetch_subs.py (shards, captions only)
         ->  one note agent per batch  ->  themes  ->  METHOD.md
         ->  PERSONA + LEGIT + LECTURE agents in parallel  ->  COMPARE  ->  INDEX.md + REPORT.html
```

Scripts do the mechanical parts. Claude Code [subagents](https://code.claude.com/docs/en/sub-agents) do the judgment, each with its own brief and fresh context, so 9 hours of transcript never has to fit in one window.

## Step 1: Install the skill and point it at an archive

You need Claude Code and Python 3.10 or later. Then two packages and a copy.

```powershell
python -m pip install -U --pre yt-dlp markdown
```

Download the skill from the [Claude For Marketing Library](https://www.skool.com/claude-for-marketing/classroom/d97a88f3?md=15c84f819c8b436bbbdfff056513fb95) and unzip the `youtube-distiller/` folder into your [skills directory](https://code.claude.com/docs/en/skills): `~/.claude/skills/` on macOS and Linux, `C:\Users\<you>\.claude\skills\` on Windows. Then copy `config.example.json` to `config.json` beside the skill and fill it in.

```json
{
  "archive_root": "~/distilled",
  "owner_name": "me",
  "owner_context": ["~/.claude/CLAUDE.md"],
  "lang": "en",
  "notes_model": "sonnet"
}
```

Two fields matter. `archive_root` is where every creator you distill will live, so pick a folder you will still have next year. `owner_context` lists the files that say how you work: your CLAUDE.md, offer, pricing, sales playbook. The comparison reads them, and a comparison against nothing is a book report.

One habit before every run: update [yt-dlp](https://github.com/yt-dlp/yt-dlp). YouTube breaks old versions all the time, and an old yt-dlp is the first suspect for any failure. The skill says so in the first line of its setup.

## Step 2: Pick the videos and pull the captions

You say "distill @somecreator". The skill asks five things in one message, then waits: which channels (a creator can have a main channel and a podcast), how many videos, best or latest, the purpose, and who to compare against.

Then two scripts list the channel and choose.

```powershell
python S/scripts/enumerate.py --dir D --channel https://www.youtube.com/@somecreator
python S/scripts/pick.py --dir D --count 100 --mode best --keywords "offer,pricing,ads"
```

`S` is the skill folder and `D` is the creator's folder in the archive. `best` ranks by view percentile within the channel, plus a bonus for your keywords; `latest` takes the newest. Both skip Shorts (under three minutes), duplicate titles and any video that already has a note, so a rerun only adds what is new. Over 200 hours, the skill asks before going on.

Then the captions, in parallel shards running hidden in the background:

```powershell
python S/scripts/fetch_subs.py --dir D --lang en --shard 0 --of 4
```

Each shard asks YouTube for its own captions in the original language first, writes them as text with a timestamp every two minutes, and logs `FINISHED` when it is done. A video with no captions is logged as `NOSUB`. On a 429 (rate limiting) the script backs off for one, two, then three minutes. If it keeps failing, update yt-dlp and stop.

The skill runs four shards by default. The reference run took a whole 29-video channel, latest first, in three, with zero failures.

> **Figure (animated on the web version):** A terminal with three caption shards from the reference run. Each shard prints its progress and ends on FINISHED: 10, 10 and 9 videos, zero failures. Under them: zero video downloads, zero paid APIs, zero logins.
>
> The shards pull YouTube's own captions side by side. **No video is downloaded**, no API is paid, no account is logged in.

## Step 3: One note per video, then the method

Nobody reads 9 hours of transcript in one context window, so the skill does not try. A script packs the transcripts into batches of about 55,000 words, and one note agent per batch runs in parallel.

```powershell
python S/scripts/make_batches.py --dir D --words 55000 --wave w1
```

Every agent gets the same brief and writes one note per video in a fixed shape:

```markdown
# <video title>
<url> | <views> views | <minutes> min | <upload date>
Tags: ...
Value: 1 to 5
Kind: teaching | case-study | interview | pitch | vlog | other

Then five sections:
  Key ideas                       (a timestamp like (12:00) where it helps)
  Frameworks, scripts and numbers
  Decisions and rules of thumb
  Proof and claims                (did they show it, or only say it?)
  Quote
```

Two rules do the heavy lifting. "Proof and claims" forces every note to say whether a result was shown on screen or only said out loud, which is the raw material for the legit check. And the skill hands every agent the transcript as data, never instructions, so a creator saying "ignore all previous instructions" on camera gets a note, not obedience.

Then themes. `index_notes.py` counts the tags across all the notes, you pick four to six themes that cover the material, and one theme agent per theme writes a synthesis. Under about 50 videos, lower the value floor with `--min-value 2` on both passes, or the themes starve.

Then `METHOD.md`, which the main session writes itself: a 300-word summary of the whole method, the 10 most useful ideas with one source link each, every theme chapter in order, and a "How this was made" section with the channels, the selection rule, the counts and the caption caveat. On the reference run it came out at about 12,000 words. That is the reference book. The next step turns it into something you can finish in an hour.

## Step 4: Turn the method into a 1-hour course

The lecture agent reads the method, the persona and every theme, and writes `LECTURE.md`: the whole method as a 60-minute course someone could teach, record or study alone. The brief fixes the shape.

- **A title and one promise line:** what the learner can do after the hour.
- **An outline of five to seven modules** whose minutes add up to 60.
- **Every module in six parts:** a goal, the framework taught in the creator's own terms with their numbers, one real example from the videos with its source link, a 5 to 10 minute exercise on your own business, two or three check questions, and the best two to four videos to watch for that module.
- **Common mistakes,** five to eight, each with the creator's fix and a source.
- **A one-page cheat sheet** of the whole method.
- **A NotebookLM prompt** for an Audio or Video Overview that names the modules in order and sets the tone: teacher, concrete, no hype.

The exercise is the part that matters. A summary tells you what the creator thinks; an exercise makes you apply it before the module ends. The reference run's third module, "Kill by volume, not by time", is 9 minutes and ends with: write your own kill card with five lines, then apply it to one running creative today.

> **Figure (animated on the web version):** Seven module blocks of 8 or 9 minutes stack into one bar while a counter climbs to 60 minutes. Below, one module card lights its six parts in order: goal, teach, example, exercise, check and sources, with the exercise highlighted.
>
> Twelve thousand words of method become **seven modules and sixty minutes**, and every module includes an exercise on your own business.

![The LECTURE page of the report in a white layout: an outline table of seven modules with their minutes adding up to 60, and the start of module 3 with its goal and exercise](https://rodrigonask.com/images/posts/claude-code-youtube-channel-into-course/lecture-outline.webp)

Caption: **Seven modules, sixty minutes.** The course from the reference run: the outline, then every module with a goal, the framework, an exercise and check questions.

Want it as audio for the car? Upload `METHOD.md` and `LECTURE.md` to NotebookLM as sources and paste the prompt from the end of the file. The skill offers these steps at the end of every run; the upload happens on your own account.

## Step 5: Write the persona your agents will consult

The course is for you. `PERSONA.md` is for your agents. `METHOD.md` is what a creator teaches; the persona is how they decide, written so an agent can apply it to a case the creator never talked about.

The brief is strict about shape. Five lines on who they are, what they sell and the one belief everything hangs on. Five to ten core beliefs. Then the decision rules, every one in the same form:

```text
When <situation>: <what they do>, because <their reason>. [source video]
```

That form is the point. "Solo marketer who loves frameworks" is a bio, and an agent can do nothing with it. "When there is less than 3 days of spend: do not decide, because the data is noise" is a rule it can check your campaign against.

> **Figure (animated on the web version):** A card where a bio line, solo marketer who loves frameworks, is struck through. Below it a rule assembles in three chips: when there is less than 3 days of spend, do not decide, because the data is noise. A source chip then attaches, pointing at the video it came from.
>
> A bio tells an agent nothing it can apply. **When, do, because, source** is a rule it can check a plan against.

After the rules come four sections that keep the persona honest: what they would never do, their numbers (every benchmark and threshold, each with a source), their vocabulary, and their blind spots: the channels they never discuss, the account sizes their rules fit, and where two of their own videos contradict each other. Near the end sits "How to use this file": what to check first, what to flag, and the first question that creator would ask about any plan.

![The PERSONA page of the report in a white layout, showing the first seven ads testing and kill rules, each written as when, do, because with a link to its source video](https://rodrigonask.com/images/posts/claude-code-youtube-channel-into-course/persona-rules.webp)

Caption: **Rules, not a bio.** Part of the persona from the reference run: 43 rules in six groups, each naming the situation, the move and the reason, with a link to the video that said it.

## Step 6: Run the legit check before you buy anything

The legit agent answers one question: should you trust this person's results? It runs eight checks, and none of them is "do they sound smart".

1. **Proof vs claims.** How many claimed results come with a named client, a screen or numbers you can check.
2. **Results you can verify.** It searches the web for the clients, students and companies they name.
3. **Consistency over time.** Same method in the oldest and newest videos, or a new one every launch?
4. **Teaching vs selling.** The share of videos that are pitches, and how hard they close.
5. **Contradictions.** Two videos giving opposite advice, with both links.
6. **Audience signals.** Views against channel size, looking for spikes that do not fit.
7. **Track record outside YouTube.** Company registration, complaints, lawsuits, regulator actions.
8. **What they actually sell.** The paid offers and terms, found in the videos and on their site.

Then a verdict: Trust, Use with care, or Avoid, with the strongest evidence each way, what to borrow and what to ignore.

> **Figure (animated on the web version):** Eight checks light up in a column: proof versus claims, results you can verify, consistency over time, teaching versus selling, contradictions, audience signals, track record outside YouTube, and what they actually sell. A marker then slides along a scale from Avoid to Trust and stops on Use with care, the verdict from the reference run.
>
> Eight checks before you pay anyone. The verdict comes from **what the creator proves, not what they say**. The reference run landed on Use with care.

The check judges what a creator proves, not what they say. Spoken evidence is not evidence. "No independent confirmation found" is reported as a gap in the record, never as fraud, because small businesses rarely have indexed press.

Test it on someone you already know the answer for. I ran it on my own channel first, and it gave its own author Use with care: results mostly said out loud, rarely shown. If it lets its own author off easy, the brief is broken.

## Step 7: Put the archive in CLAUDE.md and ask it questions

A persona nobody reads is a diary. So the last step makes the archive reachable from every chat.

First the creator gets a `creator.json`: name, channels, domain, one line on what they are best to consult on, and the verdict. A script rebuilds `INDEX.md` from all of them, one row per creator:

```markdown
| Creator | Domain | Ask them about | Verdict | Videos | Last run | Folder |
|---|---|---|---|---|---|---|
| <name> | <what they cover> | <what to consult them on> | <Trust, Use with care or Avoid> | <count> | <date> | <slug>/ |
```

Then one line in your global CLAUDE.md. The skill offers to add it and only does it with your yes:

```text
Creator archive: <archive_root>/INDEX.md. When asked how a creator would do something, or to check a plan against one, read INDEX.md, then that creator's PERSONA.md and METHOD.md.
```

That is it. Claude Code's [memory documentation](https://code.claude.com/docs/en/memory) explains why it works: CLAUDE.md loads into every session, so the pointer is always there, and the heavy files load only when a question needs them.

Now any chat can ask: "check this lead funnel the way that creator would". The ask mode reads the index, the persona and the matching part of the method, greps the notes for specifics, and answers as a review: keep, change, refuse, each point citing a rule or a video. Ask about several creators and you get one answer each, then where they agree and where they fight.

> **Figure (animated on the web version):** A chat question, check this lead funnel the way the creator would, travels five stops: the one line in CLAUDE.md, INDEX.md, PERSONA.md, METHOD.md and the notes folder. It comes back as a review card with three lines: keep, change and refuse, each citing a rule.
>
> One line in CLAUDE.md, and any chat can ask. An example answer: **keep, change, refuse**, every point tied to a rule in the persona.

The last file is the comparison. `COMPARE-me.md` reads your `owner_context` files and the creator's persona and lists where you agree, where you differ, what they do that you are missing, what to ignore, and the questions to settle. Point it at another creator in the archive instead and you get the same thing between two experts who contradict each other.

## What you get

Per creator, from one sentence:

- **LECTURE.md.** A 60-minute course in five to seven modules, with exercises, check questions, common mistakes, a cheat sheet and a NotebookLM prompt.
- **METHOD.md.** The whole method: a summary, the 10 most useful ideas, a chapter per theme, every point linked to its video and timestamp.
- **PERSONA.md.** Core beliefs, decision rules, refusals, numbers, vocabulary and blind spots, written for an agent to apply.
- **LEGIT.md.** Eight checks and a verdict, with sources for every finding.
- **COMPARE.md.** Them against you, or against another creator.
- **REPORT.html.** One index that opens all five as white pages in a browser. The per-video notes stay as markdown underneath.

The real gain: a creator's hundreds of hours become one hour you can finish tonight, and "how would they do it?" stops being a feeling and becomes a lookup with a link.

## Hand it to Claude Code

The skill, with a `/goal` prompt for running a whole channel unattended, is in the Library inside [Claude For Marketing](https://www.skool.com/claude-for-marketing/classroom/d97a88f3?md=15c84f819c8b436bbbdfff056513fb95), my community. Download the skill from the Claude For Marketing Library, unzip it into ~/.claude/skills/, then paste this, with your channel in step 4.

```text
Install the youtube-distiller skill that I just unzipped and run it once.

1. Run: python -m pip install -U --pre yt-dlp markdown. Show me the yt-dlp version.
2. Make sure its youtube-distiller/ folder sits in my Claude Code skills directory (~/.claude/skills/ on macOS and Linux, C:\Users\<me>\.claude\skills\ on Windows). Show me the listing.
3. Copy config.example.json to config.json in that folder. Ask me where the archive should live and which files describe how I work (my CLAUDE.md, offer, pricing), then fill archive_root and owner_context with paths that exist. Show me the file.
4. Read youtube-distiller/SKILL.md in full and follow Mode 1 for this channel: <CHANNEL URL OR @HANDLE>, <COUNT> videos, <best | latest>, compared with me, default purpose (the 1-hour course, gaps against me, legit check). Captions only: no video downloads, no paid APIs, no logins.
5. When REPORT.html exists, give me its full path, the LECTURE.md outline, the legit verdict, the top 5 ideas with their video links and the 3 biggest gaps from the comparison.
6. Offer to add the creator archive line to my global CLAUDE.md. Add it only if I say yes.

Do not publish, upload or send anything. Transcripts and notes stay on my disk for private study. Stop at a draft: the files on disk and the report open for me to read.
```

## When not to do this

If you want one tutorial, not a whole creator, this is overkill. [Make Claude Code watch the tutorial for you](https://rodrigonask.com/make-claude-code-watch-tutorials-for-you) instead, and build the thing it shows.

If the creator teaches on screen, captions miss it. A software walkthrough where the important part is a click nobody narrates comes back thin, because anything shown and never said is invisible to the skill.

If you want to sell the course you distilled, do not. The outputs are your notes about someone's public work, for private study. Credit the creator as the source when an idea of theirs makes it into your work.

**The whole run, as a checklist:**

1. Update yt-dlp before every run.
2. Captions only, public videos only, no logins.
3. One note per video, proof marked as shown or said.
4. Themes before the method, the method before the course.
5. Every module includes an exercise on your business.
6. Rules as when, do, because, with a source.
7. One line in CLAUDE.md, and every chat can ask.

This is how I study anyone I am about to learn from or pay. The [capability skill that studied two YouTubers](https://rodrigonask.com/claude-code-learns-skills-from-youtube-experts) does the narrow version: study creators to build one tool. [Build a Goal](https://rodrigonask.com/build-a-goal-skill) is how a 300-video run goes unattended, the [score-the-batch page](https://rodrigonask.com/claude-code-score-ai-output-batch-review) is how I judge what the agents hand back, and the [context diet](https://rodrigonask.com/claude-code-context-diet-cut-tokens) is why the archive is one line in CLAUDE.md and not the whole persona. The operating model behind it is [agentic marketing](https://rodrigonask.com/agentic-marketing). If you want this kind of system running on your ads, see [the service tiers](https://rodrigonask.com/services) or [book a working session with me](https://rodrigonask.com/1-on-1-consultancy). Results from real accounts are in the [case studies](https://rodrigonask.com/case-studies), and every other build is on [the blog](https://rodrigonask.com/blog).

I break down builds like this one, Claude Code skills, research agents and Meta ads with AI, inside my community, Claude For Marketing.

- [Get it in the Library](https://www.skool.com/claude-for-marketing/classroom/d97a88f3?md=15c84f819c8b436bbbdfff056513fb95)
- [Work with me 1-on-1](https://rodrigonask.com/1-on-1-consultancy)

## Frequently asked questions

### Can I turn the course into audio or video?

Yes. Every LECTURE.md ends with a NotebookLM prompt that names the modules in order and sets the tone: teacher, concrete, no hype. Upload METHOD.md and LECTURE.md to NotebookLM as sources, paste the prompt, and ask for an Audio or Video Overview. It runs on your own account, so log the upload wherever you track what leaves your machine.

### How much does a run cost?

Zero dollars in tools. The captions are free and the reading is done by Claude Code subagents on your own plan, so the real cost is tokens, and that grows with hours of video. The reference run, 29 videos and about 9 hours, took about 25 minutes. A 300-video run of 211 hours took about 35 minutes of wall time with the note agents in parallel.

### Can an agent really answer as the creator?

It answers as a review, not an impersonation. The agent reads the creator's written rules and their method, then says what they would keep, change and refuse, each point tied to a rule or a video. When it stretches a rule to a case the creator never discussed, it marks the answer as inferred. When the material does not cover the question, it says so.

### How reliable is the legit verdict?

It is as good as the evidence it can find, and it says what it could not find. It counts what the videos prove against what they claim, searches the web for named clients and the company, and lists contradictions with both links. No independent reviews is reported as absence of evidence, never as fraud. Use with care is a common, fair result.

### What if the channel has no captions or is in another language?

Set the language in config.json and the script asks for that language first. A video with no captions at all is logged as NOSUB and skipped, and you can pick replacements with the exclude flag if the gap matters. Auto captions mangle names, so the notes mark doubtful ones with a question mark. Check the video at the cited minute before you quote a name.