🎬 tuto.

Let AI watch YouTube for you.

Turn YouTube videos into verified working knowledge for AI agents — transcripts, screen text, slides, UI, charts, numbers, actions, and timestamps.

유튜브 영상을 직접 보지 않아도 됩니다.

AI가 대신 영상을 보고, 자막과 화면을 함께 이해하고, 검증된 지식으로 변환합니다. 이후 AI는 그 내용을 설명하거나 질문에 답하고, 현재 작업과 비교하거나 튜토리얼을 따라 할 수 있습니다.

/tuto <youtube-url> [자연어 요청]

---

One interface

모드를 외울 필요가 없습니다. 영상 URL과 하고 싶은 말을 그대로 적으면 됩니다.

/tuto <url> 이 영상 내용을 내가 이해할 수 있게 설명해줘
/tuto <url> 여기서 알려주는 방법과 우리 프로젝트를 비교해서 적용할 점을 찾아줘
/tuto <url> 영상에서 사용한 설정값과 명령어를 정확히 정리해줘
/tuto <url> 이 튜토리얼을 이해한 다음 현재 프로젝트에 적용해줘

요청은 분석 깊이를 바꾸지 않습니다. "핵심만 알려줘"라고 해도 영상을 얕게 보지 않습니다 — 사용자는 영상을 직접 보지 않으므로 무엇이 빠졌는지 검증할 수 없기 때문입니다. 요청이 바꾸는 것은 수집한 지식을 어떻게 쓸지입니다.

Separation of concerns tuto = eyes + video understanding · calling agent = reasoning + hands

산출물	용도
evidence.json	기계가 읽는 정본 — 근거가 프레임·타임스탬프까지 추적됨
video.md	사람이 읽는 문서 — 영상 구조에 맞춰 자율 구성 (고정 템플릿 없음)

Why evidence, not summaries

The values that matter in a video are often never spoken — they exist only on screen.

Caption / ASR said	Screen actually showed
python	python3 — confirmed by a user following along
slowdown 98x	0.98x — the Korean ASR dropped the decimal point
16x difference	16.3x — 90,991 vs. 5,584
600 followers	576
irresistible	irresistable — the original on-screen typo is preserved
embedding dimension 136	1536 — an agent following the caption builds 136-dim vectors and every call fails

tuto treats the screen as evidence. When captions and frames disagree, the frame wins and the conflict is preserved as structured data — not buried in prose:

{
  "id": "c1",
  "claim": "훅 A/B 조회수 격차가 16.3배",
  "timestamp": 132.0,
  "evidence": [
    { "source": "frame",      "ref": "v1" },
    { "source": "transcript", "ref": "42" }
  ],
  "conflict": { "transcript": "16배", "screen": "16.3x" },
  "verification": { "status": "unaudited" }
}

That conflict field is the point. An agent can programmatically find the gap between what a presenter claimed and what their own slide showed.

If a value cannot be read safely, tuto emits ⚠️ needs visual check instead of guessing. Transcript evidence and visual evidence are never merged into one source — "source": "both" is rejected by the schema.

Separation of concerns. tuto answers what was said and what was on screen. What it means for you is the calling agent's job.

evidence.json — full structure

{
  "schema_version": "0.3",
  "video":       { "id", "title", "url", "duration", "channel" },
  "video_type":  { "primary": "tutorial|presentation|interview|lecture|demo|screen-recording|mixed",
                   "confidence": "high|medium|low", "hint": { /* deterministic signal-based hint */ } },
  "provenance":  { "transcript": { "source", "lang", "segments", "dupes_removed" },
                   "signals":    { "heatmap", "chapters", "activity_peaks", "flags" },
                   "frames":     { "map": [ { "file", "t", "res" } ], "zoom": [ ... ] } },
  "segments":         [ { "idx", "start", "end", "transcript" } ],
  "visual_evidence":  [ { "id", "type", "value", "timestamp", "frame", "confidence" } ],
  "claims":           [ { "id", "claim", "evidence", "conflict", "verification" } ],
  "knowledge_items":  [ { "id", "type", "content", "timestamp", "evidence", "verification" } ],
  "gaps":             [ { "start", "end", "reason" } ],
  "flags":            [ ... ]
}

Confidence is never a fabricated number — the pipeline has no basis for probability estimates, so only high|medium|low and verified|disputed|unverifiable|unaudited are allowed. unaudited is deliberately distinct from verified: verification is handled by the coverage audit and the deterministic cross-check, and no step assigns verified, so an evidence.json shows unaudited on effectively every item — that must not look like passing. See Limitations.

Full spec: docs/eval/evidence-schema.md

---

Quick start

1. Add the marketplace

claude plugin marketplace add dingmon1019/YoutubeAnalyzer

2. Install tuto

claude plugin install tuto@yta

Restart Claude Code, then run:

/tuto https://youtu.be/VIDEO_ID

Or just say what you want:

/tuto https://youtu.be/VIDEO_ID 이 영상에서 가장 중요한 주장 5개와 근거를 알려줘
/tuto https://youtu.be/VIDEO_ID 이 튜토리얼을 우리 프로젝트에 적용해줘

Already analyzed? Ask without re-downloading:

"아까 영상에서 16.3x가 무슨 의미였어?"

Output:

~/.yta/cache/<video_id>/evidence.json    ← canonical, for agents
~/.yta/cache/<video_id>/video.md         ← human-readable

Update

claude plugin update tuto@yta

Requirements

Requirement	Install example
Python 3.11+	—
ffmpeg / ffprobe	winget install Gyan.FFmpeg · brew install ffmpeg
yt-dlp	pip install -U yt-dlp
optional: faster-whisper	pip install faster-whisper

A preflight check runs on first use and tells you what is missing.

Optional configuration

~/.config/yta/.env is created automatically on first use.

GROQ_API_KEY=          # Only needed for Groq ASR on videos without usable captions
CACHE_MAX_VIDEOS=10    # Maximum cached videos that retain video.mp4

No API key is required. Transcript acquisition falls back through native captions → Groq → local Whisper → frame-only analysis.

---

What you get

video.md의 구조는 영상에 따라 달라집니다. 튜토리얼이면 절차 중심, 강의면 개념 중심으로 조직됩니다. 유튜브 챕터가 3개 이상이면 영상 길이와 무관하게 시간순 챕터 절(### [MM:SS] 챕터 제목)로 구성되고, 그렇지 않으면 아래처럼 기존 유형별 구성을 따릅니다.

## Step 4: Run installer—Add Python to PATH + Install Now (02:56–04:05)

1. Open the installer → "Install Python 3.9.6 (64-bit)".
   Default path: `...\AppData\Local\Programs\Python\Python39` (t=03:23)
2. "Install launcher for all users (recommended)" is checked.
   "Add Python 3.9 to PATH" is unchecked at this frame. (t=03:23)
3. ⚠️ The exact checkbox and click moments are hidden by a transition. (t=03:51)

## Verification stamp
Sample audit: not run — evidence is frame/caption-traceable but not independently audited.
Cross-check: 1 value disagreement flagged (recorded, not re-verified).
Coverage audit (haiku): 1 missing knowledge item recovered.

Follow-up questions in the same session reuse cached frames and captions, so the video does not need to be downloaded again.

---

Measured results

Numbers below are measured end to end, not estimates. The benchmark is a 54-minute, screen-dense ads tutorial; the rest are real videos run once each. This is per-video regression evidence, not a statistical claim.

Current performance

	Benchmark (54 min, screen-dense)	RAG lecture (24 min)
Cost	$4.76	$5.08
Wall clock	14.6 min	15.0 min
Knowledge items	171	66
Screen-grounded	69	21
Uncited observations	0%	0%
Format rejections	0	0

Every knowledge item carries a timestamp. "Screen-grounded" counts the items whose evidence cites an actual frame file — the number that says whether the pipeline read pixels or paraphrased captions.

Run-to-run variance is real and worth stating. The same code produced $4.76 and $7.29 on the benchmark. The chain is traceable: the analysis agent picked 4 zoom points instead of 8, which starved the screen material, left knowledge short of its floor, and sent synthesis working longer to reach it. That link is model judgment, not a deterministic step.

Screen-value gate — five videos

tuto reads a video's captions before touching a single frame and asks whether the screen carries information worth reading. low stops and asks; high passes silently.

Video	Verdict	Cost	Outcome
Music playlist, 28 min	low	$0.38	0 frames read, asked
Game review, 16 min	low	$0.67	0 frames read, asked
RAG lecture, 24 min	high	$5.08	21 of 66 items screen-grounded
Ads tutorial, 54 min	high	$4.76	69 of 171 items screen-grounded
Talk show, 82 min (before the gate existed)	—	$9.89	274 items, 1 screen-grounded

The last row is why the gate exists. The RAG lecture is why the pipeline exists: it caught three caption-vs-screen disagreements and adopted the screen each time, including an embedding dimension the auto-captions rendered as 136 against the screen's 1536.

Compared against watch

watch is the sibling skill — download, sample frames, read captions, answer. Same video, same model, same settings:

	watch	tuto
Cost	$1.78	$4.76
Time	5.1 min	14.6 min
Output	3,971-character prose answer	evidence.json 380 KB + video.md 33 KB
Timestamps	3	171 — one per knowledge item
Values read from screen pixels	not distinguished	69, each traceable to a frame file

Cost scales differently: watch follows transcript length, tuto follows how much work it does per frame. If a person is going to read the plan, watch is cheaper and sufficient. tuto earns its multiple only when an agent has to act on those values, or when a wrong value has to be traceable back to the pixel it came from.

Regression suite: 785 tests (python -m pytest tests/ -q).

How it works

ORCHESTRATOR (본체 — never Reads an image; scripts + ONE dispatch)
──────────────────────────────────────────────────────────────────
analyze.py ─→ [SCREEN-VALUE gate] ─→ --k-budget ─→ [dispatch: AGENT A] ─→ --from-lines --cross-check ─→ --render(+--audit)
├ yt-dlp        knowledge      (sonnet, foreground)     merge + schema gate         deterministic doc
├ captions      floor/ceiling       │                   screen_check                verification stamp
├ heatmap       from measured       │                   hash/number reread          AUDIT line
└ map frames    info volume         │
                                    ▼
              AGENT A — one context sees everything, start to finish
              ──────────────────────────────────────────────────────
              map frames Read → V-lines → pick zoom targets → zoom.py
              → zoom frames Read → V-lines → synthesize K/C/G (cites
              what it SAW) → self-check (--check-lines, --validate-lines)
              → writes vision-*.lines + patch.lines

Code orchestrates, one agent analyzes — the orchestrator (본체) runs every deterministic step itself (download, budget, merge, cross-check, render, audit) and makes exactly one dispatch: Agent A reads the frames, picks and extracts zoom targets, transcribes, and then synthesizes knowledge in the same context that saw the screens — measured against the split architecture (six dispatches), this cut cost 36%, time 39%, and produced the highest screen-grounded settings count ever recorded (40), because the transcribe→synthesize handoff loss disappeared. A day of measured alternatives (parallel synthesis shards, a two-agent split, prompt dieting) all lost to it; the full record is in docs/eval/reports/2026-08-23-architecture-convergence.md. A conditional coverage audit (haiku, text-only) runs only when knowledge lands below the information-volume floor. Every safety rail is deterministic and measured at zero violations: transcript-source merges are refused (REFUSED), missing outputs fail loud (exit 4), lost originals warn (WARN), and every run ends with a one-line AUDIT (uncited ratio / source preservation / floor shortfall / frame provenance).

evidence.json이 정본이고 video.md는 그것을 사람이 읽게 조직한 것입니다. 문서를 먼저 쓰고 근거를 맞추지 않습니다 — 순서가 바뀌면 문서에 맞춰 근거를 지어내게 됩니다.

0. Screen-value gate — asking before the expensive part

tuto is a screen-reading tool. On a video whose value is entirely in speech — an interview, a music playlist, a game review — it will still run the whole vision pipeline and then produce knowledge that came from captions anyway. Measured: an 82-minute talk show cost $9.89 and produced 274 knowledge items of which exactly 1 was screen-grounded.

Deterministic signals cannot catch this. Measured across three videos:

Signal	Talk show	Music	Tutorial
Frames dropped as duplicates	0/34	27/29	0/34
Instructional cues found	40	1	40
Activity peaks	314	3	82
TYPE_HINT (caption density)	interview	interview (wrong)	tutorial

The talk show has camera cuts, so no duplicate frames; and Korean conversational speech contains 여기 / 이거 / 보시면, so the cue extractor fired 40 times. Only the content tells you.

So a disposable haiku agent reads pass1-report.txt — the orchestrator never loads the transcript itself, which would put ~26.8K tokens in context for the rest of the run — and answers in one line:

SCREEN-VALUE: high · 근거: Ads Manager 설정값·메뉴·버튼 클릭 위치를 단계별로 설명
SCREEN-VALUE: low  · 근거: 자막이 전부 가사이고 map_frames=2(27장 중복 제거)

high passes silently. low stops and asks, showing its reasoning and pointing at watch as the cheaper alternative. A failed or malformed verdict is treated as high — a gate that breaks toward blocking the pipeline is worse than no gate.

It asks rather than decides, so a wrong verdict costs one question. That property is the design: the judgment is an LLM's, and this project's measurements say LLM judgment is a lottery — so the lottery was placed where losing is cheap.

Measured across five videos:

Video	Verdict	Cost	Outcome
Music playlist, 28 min	low	$0.38	0 frames read, asked
Game review, 16 min	low	$0.67	0 frames read, asked — and volunteered "the link may have been pasted by mistake"
Insomnia talk show, 82 min	(pre-gate)	$9.89	274 items, 1 screen-grounded
RAG lecture, 24 min	high	$5.08	66 items, 21 screen-grounded — passed silently
Ads Manager tutorial, 54 min	high	$4.76	171 items, 69 screen-grounded

The RAG lecture is why the tool exists: it caught three caption-vs-screen disagreements and adopted the screen each time — including the embedding dimension the auto-captions rendered as 136 against the screen's 1536.

1. Signal-weighted frame selection

Uniform sampling and scene-change detection can skip static screens—exactly where tutorials often show settings, terminal commands, tables, and configuration values.

tuto combines YouTube heatmaps, chapter boundaries, activity peaks, caption cue words such as “click” / “look here,” and frame-gap detection.

2. Resolution tiering

Text-heavy frames such as slides, tables, menus, and terminals are extracted at 1024px; illustrations, transitions, and talking heads use 512px. Zoom points chosen without map coverage should be requested at 1024px (see SKILL §2). zoom.py itself will not process more than 20 high-resolution frames or 60 total frames per call. The orchestrator makes a single zoom.py call per analysis and keeps it far under that ceiling — a self-imposed budget that now scales with video duration (see Duration-proportional budgets below), plus at most one --crop follow-up.

3. Gap detection

Low-motion verification sections near the end of tutorials are easy for samplers to miss — tuto explicitly revisits gaps rather than trusting uniform or scene-change sampling alone. This rule was added after two measured runs omitted entire conclusion sections. It started as a flat, always-on 60-second threshold; it is now a duration-gated, activity-targeted stage with its own measured results — see Gap-targeted backfill below.

4. Deterministic cross-check

Per-claim adversarial sample audits are not run. Measured across 4 videos, they corrected 0 of 24 verdicts, so verification is left to the coverage audit and the deterministic cross-check.

evidence.py --cross-check re-reads hashed and numeric values across visual_evidence, claims, and knowledge_items looking for internal disagreement — at zero additional cost, since it is deterministic post-processing rather than a subagent call. A disagreement is recorded as a count (--cross-flags), not re-verified: recent flags measured as false positives across the board, so an automatic recheck would spend money to confirm values that were already right. See Lenient validation contract.

Cross-check cannot catch a reading that is wrong but internally consistent — a value nobody disagreed with is not the same as a value someone independently verified. That gap is why verification.status defaults to, and effectively stays at, unaudited (see Limitations).

5. Coverage audit

Coverage audit builds an expected knowledge checklist from the source and compares it against claims and knowledge_items in evidence.json — not against document headings.

An adaptive video.md heading like ## Phase 1 says nothing about what it contains, and evidence.json is the canonical source anyway. So completeness is checked as source → evidence first, and evidence → video.md second.

It is the pipeline's only subagent call, and it runs on haiku: it receives evidence.py --coverage-input (a digest of claims/knowledge_items) plus the pass1-report.txt transcript — text only, image reads are explicitly forbidden in its prompt. It is asked what a viewer of the transcript would expect to know that the digest does not already contain, not asked to re-derive values from frames. Candidates it returns are checked against the transcript before being merged in — coverage audit proposes gaps, it does not write them unconfirmed.

6. Duration-proportional budgets

Fixed per-run ceilings quietly starved long videos: a 32-minute tutorial measured against the same map-frame and knowledge caps as the 11-minute regression baseline came out at roughly a third of the knowledge density (0.9 items/min vs. 2.7). Budgets now scale with video length instead of a flat number:

Resource	≤20 min	20 min+
Map frames	0.7/min (unchanged)	1.0/min, capped at 34
Zoom targets	up to 4	6–8
Knowledge items	information-volume budget	information-volume budget

A ceiling alone did not raise density. Allowing up to 2.5 knowledge items/min still left the model stopping at 40 items on a 32-minute video — a ceiling caps runaway extraction, it does not tell the model to keep extracting. Adding an explicit 1.5 items/min floor as a target moved the same video to 76 items (2.35/min) on the next run. See Measured results for the full before/after.

The knowledge budget keys on information volume, not duration. Duration is only a proxy for how much a video actually says: the same ten minutes can be a playlist rundown or a dense tutorial, and a flat per-minute rule over-permits the first while truncating the second. evidence.py --k-budget now measures the information actually in hand at synthesis time — transcript character count, corrected by CJK ratio because Korean carries roughly twice the information per character, plus the number of screen V-lines — and emits KFLOOR n KCEILING m for the orchestrator to inject into the synthesis dispatch. Frame and zoom budgets remain duration-proportional as above. See docs/eval/reports/2026-08-22-info-budget.md.

7. Gap-targeted backfill

Videos over 20 minutes get one more pass after the standard pipeline. evidence.py --gap-plan computes gaps over 90 seconds deterministically from frame timestamps — both this threshold and the 20-minute trigger are enforced in code, not in prose, so shorter videos incur no extra cost. Each gap is targeted at its activity-signal peak rather than its midpoint, and the result is capped at 12 frames, longest gaps first if that cap would be exceeded.

Those frames are then transcribed blind — the transcription pass receives the frame paths but not the caption transcript, so it has no caption context to backfill screen content from. This is a structural defense against confabulation: the same model that fabricated two values when given captions produced zero fabrications once captions were withheld (see Measured results). The result is checked against the existing knowledge digest, and only new items are merged in.

Activity-signal targeting still misses quiet screens — scenes with typing but little visual change or verbal cue, such as editing a .env file. See Limitations.

8. Selective registration

검수(비전 서브에이전트가 프레임을 읽는 것)는 이전과 동일하게 전량 수행된다 — 줄어드는 것은 등재뿐이다. synthesize.md는 이제 vision-*.lines의 V라인을 전부 patch로 옮기지 않고, knowledge_items/claims가 refs로 실제 인용하는 V만 옮긴다(v#는 patch 내 등장 순서로 재부여). 인용되지 않은 관측은 버려지지 않는다 — 원본 vision-*.lines가 캐시(<cache_dir>/)에 그대로 남아, 정본(evidence.json)에 없는 관측을 묻는 후속 질문이 오면 그때 Read해 지연 로딩한다.

측정(20분 튜토리얼, 도입 전 → 후): 비용 $5.17 → $2.98(−42%), 등재된 V 155 → 21. 자세한 수치는 Measured results 참고.

9. Lenient validation contract

evidence.py --from-lines는 더 이상 낱줄(T/V/K/C/G) 하나의 형식 오류로 배치 전체를 거부하지 않는다. 알 수 없는 레코드 종류만 여전히 즉시 거부하고(스키마 자체가 다르다는 신호이기 때문), 파싱 가능한 필드가 부족한 낱줄은 드롭 + 카운트해 stdout에 MERGED ... DROPPED n으로 보고한다(재전달 대상이 아닌 정보성 보고 — 이전에는 전량 거부가 재시도 스파이럴로 번졌다). knowledge_items/claims만 드롭율이 20%(KC_DROP_RATE_GATE)를 넘을 때 배치 전체를 INVALID로 거부한다 — 이 둘이 실제 지식을 나르고, 드롭율이 높다는 것은 산발적 오타가 아니라 파일 전체가 잘못된 규약이라는 신호이기 때문이다. 교차 대조가 남기는 flag도 같은 정책으로 단순화됐다: 비전 서브에이전트를 다시 불러 재판독시키던 루프는 폐지되고 건수만 --cross-flags에 기록된다(최근 flag가 전부 오탐으로 측정됨 — 교차 대조 참고).

철학: 완전성 > 문자 정밀도 — 오타는 허용하되, 날조는 구조(blind 전사, §7)로 차단한다. 이 관용은 형식 오류에만 적용된다 — 절차 단계를 합치거나 누락하는 것은 관용 대상이 아니다. synthesize.md는 "따라하기 절차의 단계는 합치지 마라 — 단계 하나가 K 하나다"를 명시한다(같은 사실의 재표현만 병합 허용).

부수 버그 수정. 관용 드롭이 v-id에 결번을 남길 수 있게 되면서(예: v1·v3 생존, v2 드롭) 다음 배치의 id 오프셋을 len(visual_evidence)로 계산하던 기존 로직이 이미 존재하는 id와 충돌하는 버그가 드러났다 — 오프셋 계산을 "기존 v-id 중 최대 숫자" 기준으로 교체해 수정했다.

---

What the audits have caught

Defect	How it was resolved
Non-existent visual effect caused by double frame attribution	SSIM across 11 frame pairs separated same frames (0.994) from distinct frames (0.634)
83K misread as the true value	Native-resolution re-extraction + 22× crop showed 84K
“13.1× average views” missing its denominator	Summary ↔ body consistency check recovered “vs the 19 no-ask posts”
Slide contradicted itself (20,542 vs. 21,022)	Same-slide arithmetic (576 + 19,966) exposed the inconsistency
Empty table cell filled from captions	Output now preserves (icon only) / (아이콘만) and separates Caption source: / 자막 출처: evidence

---

Evaluation tooling

Cost accounting

python docs/eval/measure-cost.py --marker VIDEO_ID

The tool separates orchestrator and subagent cost, deduplicates repeated records by message.id, and applies the repository's fixed effective-token weighting. Use --until or a dedicated session to avoid counting unrelated work that follows a /tuto run.

Golden-set evaluation

See docs/eval/golden-set-protocol.md.

• R1 Recall—did the guide miss an action the user needed to perform?
• Value F1—are reproducible settings and quoted source values correct?
• Operable values are the primary regression metric; reported values are tracked separately.
• LLM matching must be checked by a user at least once before results are finalized.

---

Limitations

• Designed primarily for videos ≤30 minutes; longer videos prompt for a narrower range.
• Conceptual videos are supported, but the output becomes a guide to visible rules, slides, and values rather than a click-by-click procedure.
• tuto verifies screen ↔ claim consistency. It does not prove that the video's advice itself is factually correct.
• Values not visible in evidence frames are intentionally left unresolved instead of inferred.
• Developed and validated on Windows. macOS/Linux are not yet fully validated.
• 산출물은 근거 추적은 되나 표본 감사를 거치지 않는다 — 값은 프레임으로 재확인 가능하다.
• 작은 화면 글자(축약 명령어·설정 키 등)는 비전 서브에이전트가 오독할 수 있다 — 영상당 약 1건 발생 가능. 교차 대조·⚠️ 표기·커버리지 감사 3중 안전망이 부분적으로 방어하지만(실측: 11분 영상에서 교차 대조가 100↔200 오독 1건을 재확인으로 정정, 32분 영상에서는 flag 9건 중 1건이 실제 오독으로 판정돼 정정됨 — 108→105 KiB/s, 나머지 8건은 정확 확인) 완전히 막지는 못한다.
• "조용한 화면"(타이핑만 있고 화면 변화·언급이 적은 장면 — 예: .env 편집)은 공백 표적 보강의 activity 신호 조준으로도 잡히지 않는다. 그런 장면이 공백 안에 있으면 회수되지 않으며, 남은 공백은 산출물에 그대로 보고된다(실측: docs/eval/reports/2026-08-19-gap-backfill.md).
• 전사 밀도가 실행 간 요동한다 — 같은 영상, 같은 프롬프트에서도 확대 전사가 125줄 ↔ 42줄로 3배 가까이 차이 난 사례가 실측됐다(선별 등재 게이트, 2026-08-21). 이 요동은 지식량을 최대 ±30% 흔들 수 있고, 파이프라인 전반에 걸쳐 관측되는 조건이다 — 원인 분리는 됐으나 해결은 아직이라 다음 라운드의 표적으로 남겨둔다(실측: docs/eval/reports/2026-08-21-selective-reg.md).

---

Cache management

Artifacts are stored in ~/.yta/cache/<video_id>/. When CACHE_MAX_VIDEOS is exceeded, the oldest cached video.mp4 and audio.mp3 files are removed while metadata, evidence.json, and video.md are preserved.

Run cleanup manually with:

python skills/tuto/scripts/analyze.py --cleanup

---

Contributing

Issues, bug reports, benchmark videos, and pull requests are welcome.

Especially useful contributions include:

• reproducible cases where the screen and captions disagree
• macOS / Linux validation
• tutorials where an important step is missed
• false-positive or over-aggressive audits
• performance or token-cost regression cases

If a tutorial breaks tuto, a public video URL and the missed timestamp are especially useful. See CONTRIBUTING.md.

---

Docs

Document	Purpose
skills/tuto/SKILL.md	Orchestrator pipeline contract
docs/superpowers/specs/	Design specs by iteration
docs/superpowers/plans/	Implementation plans
docs/eval/evidence-schema.md	evidence.json schema — canonical spec
docs/eval/	Golden-set protocol and cost tooling

---

License

MIT © 2026 hwangjs

If tuto saves you from scrubbing a video frame by frame, consider giving the repo a ⭐.

_{Built as a Claude Code plugin · 352 tests passing}