SkillsSkill for Claude

Course localization text sheet

Hand Claude a folder of finished course modules and get one spreadsheet of every piece of text burned into the picture that has to be redone for another language. Claude prices the job against your Vivu plan, has you upload the modules to a private project, runs one search per kind of on-screen text, checks every result against frames from your own files, sweeps each module with a local contact sheet for what the searches missed, and reads the original wording from full frames. Title cards, presenter name strips, diagram labels, arrow tags over screen recordings and license end cards are not in any transcript, and the motion graphics files are often gone, so the frames are the only source.

Maintained by Vivu. Updated 2026-11-19.

Download

course-localization-text-sheet.zip

9 KB. Unzips to course-localization-text-sheet/SKILL.md. Upload the zip as it is in the Claude app, or unzip it into your skills folder for Claude Code.

SHA-256 014c66ce991c6b30f85f85d9639b0009d607a8b9875d5600acd53d10cd8baa8d

At a glance

What the Course localization text sheet skill does, where it runs, what it needs, and when it asks
Looks forTitle and end cards, labelled diagrams and maps, presenter name strips, callouts added over screen recordings and bullet slides: text that exists only in the picture, never in a transcript. Every search result is checked against frames from the original module before it goes in the sheet, and the wording is read from a full frame, not from Vivu's reason text.
Runs onClaude Code on your computer (terminal or the Code tab of Claude Desktop), because it needs a shell with ffmpeg and the module files on local disk. No downloads, so no residential IP is needed, and nothing is scheduled.
Needs
  • The Vivu connector with write access, to create a private project, open its upload page and search.
  • ffmpeg and ffprobe on the computer that holds the modules, to measure minutes and extract every frame the sheet relies on.
  • The finished module files in one local folder, because every check and every wording comes from these files.
  • Your own browser, or a browser tool that can attach local files, to upload the modules to Vivu.
  • The right to adapt and translate the course, since a localized version is a derivative work.
Your Vivu planIndexing uses one index minute per minute of course video, once per course, and each category search is one precise search; Claude measures the modules and shows the minutes and credits against your plan before anything is uploaded. In our test run 6 course videos totalling 23.25 minutes were ready about 7 minutes after the upload started.
Asks you firstBefore uploading: confirms the course is yours to adapt and the presenters agree to localized name strips, then shows the index minutes and search credits against your plan and waits for approval. Before writing the sheet: shows one sample row and the field mapping and waits for a yes.

The skill does its video work through the Vivu connector. If the connector is not in your Claude yet, add it first; the skill checks that it is connected before it does anything else.

Before you run it

  • Use it only on courses your organization owns or may adapt and translate; stock photos or partner logos credited on end cards may have their own reuse terms.
  • Search results are candidates: the callout and bullet slide searches returned highlight boxes and web pages as well, so every window is checked against frames before anything reaches the sheet.
  • Searches can miss short end cards and repeated graphics, so the skill sweeps every module with a local contact sheet; an empty search result does not prove the course has no such text.
  • Wording comes from full frames, never from Vivu's reason text, which can describe text that is not on screen; tiny license text is marked UNCERTAIN.
  • Uploads go through Vivu's upload page in your browser; Claude in Chrome accepts at most 10 MB per upload call, larger files go through your own browser or the Vivu web app.
  • The modules stay in your Vivu project until you delete them; the skill creates the project as private because the default is visible to your whole organization.
  • It writes only a local CSV; it does not produce subtitles, translate the video, edit it, or identify people or logos.

Start it

Once the skill is installed, ask for the task in your own words. Naming the skill is the most reliable way to have Claude use it. For example:

We're localizing our English course into Spanish. The finished modules are in ~/courses/intro-module-exports. List every piece of on-screen text we need to redo, with timestamps and the original wording, for the translators and the motion designer.

In Claude Code you can also type /course-localization-text-sheet. Claude asks for anything the request leaves out, most important first.

What is inside

  1. When to use
  2. Working principles
  3. What you need before starting
  4. Inputs to collect
  5. Files and state
  6. Step 1: Check the Vivu connector and the setup
  7. Step 2: Measure the modules and price the job
  8. Step 3: Create the project and upload
  9. Step 4: Search once per kind of on-screen text
  10. Step 5: Check every window against the user's files
  11. Step 6: Sweep each module for what the searches missed
  12. Step 7: Pin the times, read the text, and write the sheet
  13. Compliance
  14. Known failure modes

The full skill

This is course-localization-text-sheet/SKILL.md from the download, as Claude reads it: the frontmatter first, then the instructions.

---
name: course-localization-text-sheet
description: "Build a localization sheet of text burned into finished course videos (title cards, diagrams, name strips, callouts) with Vivu. Use before translating a course into another language."
---

Course localization on-screen text sheet with Vivu

This skill turns a folder of finished course modules into one spreadsheet of every piece of text that is burned into the picture and has to be redone for another language. Claude measures the modules, prices the job against the user's Vivu plan, has the user upload the files into a private Vivu project, runs one search per kind of on-screen text (title and end cards, diagrams with labels, name strips, callouts added over screen recordings, bullet slides), checks every result window against frames from the user's own files, sweeps each module with a local contact sheet to catch what the searches missed, reads the original wording from full frames, and writes onscreen_text.csv with empty translation and redo columns for the translators and the motion designer.

The value is in text that exists only in the picture. A transcript or subtitle file has what the presenter said, but not the module title card, the presenter's name strip, the labels inside a process diagram, the arrow tags an editor added over a screen recording, or the license text on the end card, and the motion graphics project files are often gone by the time a course is localized. Presenters rarely read a diagram's labels out loud, so the transcript cannot stand in for the frames. Vivu finds candidate windows by kind of graphic; the wording always comes from a frame Claude reads, never from Vivu's reason text.

When to use

Use when someone says "we're translating our course, what text on screen has to be redone", "list every title card and diagram in these modules for the translators", "build a localization text sheet for this course", or "what motion graphics do we need to rebuild for the Spanish version". For one question about one module ("what does the end card say in module 3"), open the file or search Vivu directly. For subtitles or translating the narration, use a transcription tool; this skill does not produce subtitles, translate the video, or edit it.

Working principles

  1. Report measured numbers, not estimates. When a number is an estimate, say so.
  2. Nothing goes into the sheet as verified until a frame from the user's own file shows it. Search windows stay candidates until checked, and the wording is read from the frame, not from the reason text, which can describe text that is not on screen.
  3. Stop and tell the user when a required capability or tool is missing. Do not guess around it.
  4. Ask the user before anything that is expensive to redo or acts on their behalf: indexing (it uses plan minutes), the field mapping before the sheet is written in bulk.
  5. Searches miss things. A kind of graphic with no result does not prove the course has none, which is why Step 6 sweeps every module locally.

What you need before starting

Check each item at the start of the run and tell the user plainly what is missing before doing anything else.

Requirement Why How to check
Vivu connector with write access create a private project, open its upload page, search vivu_get_account shows can_create_projects: true (tool names may carry a server prefix). A write call failing with "has not granted vivu.write" means the connection is read only; ask the user to reconnect Vivu with write access
A shell with ffmpeg and ffprobe, on the computer that holds the module files measure minutes, extract frames and contact sheets from the user's own files ffmpeg -version and ffprobe -version
The finished module files in one local folder Vivu searches its copy, but every check and every frame in the sheet comes from these files ls the folder; ffprobe one file
A way to upload: the user's own browser, or a browser tool that can attach local files moving the modules into Vivu the user can open a link on this computer; Claude in Chrome accepts at most 10 MB per upload call
The right to adapt and translate the course localization is a derivative work the user confirms in Step 1

This runs in Claude Code on the user's computer (terminal or the Code tab of Claude Desktop), because it needs a shell and the local files. It downloads nothing, so no residential IP is needed. Nothing recurs, so there is no scheduled task.

Inputs to collect

Ask for anything missing, most important first.

  1. The folder with the finished module files (mp4, mov or similar). Required.
  2. The target language, recorded in config.json and named in the reply that delivers the sheet. Required.
  3. Which kinds of text to list. Default: title_card, diagram, name_strip, callout, bullet_slide, plus ui_text (software interface text inside screen recordings) from the local sweep only.
  4. Whether to index every module or a representative subset first. Default: all modules if they fit the plan, otherwise the subset lever in Step 2.
  5. The Vivu project to reuse, if the course is already indexed. Default: create a new private project.

Files and state

Keep everything in one working folder next to the modules:

course-localization/
  config.json        target language, module folder, project_id, file name map, chosen categories
  state.json         completed steps, job_id per category, checked window keys (file + start_ms)
  results/           raw search results, one JSON per category
  frames/            start, middle, end frames for every window; 0.5 s strips; full read frames
  sheets/            2 s contact sheets per module (Step 6)
  candidates.csv     every search window with its check result (verified, false positive)
  onscreen_text.csv  the deliverable

state.json records which steps finished and which windows were checked, so a rerun after an interruption skips completed searches (it reuses the saved job_id and raw file) and never checks or lists the same window twice.

Step 1: Check the Vivu connector and the setup

Goal: every requirement is present before anything is uploaded.

  1. Call vivu_get_account. If the tool does not exist, tell the user to add the Vivu connector in Claude (https://mcp.vivu.ai/mcp) and stop. It must show can_create_projects: true. If a later write call fails with "has not granted vivu.write", ask the user to reconnect Vivu with write access.
  2. Run ffmpeg -version and ffprobe -version. If either is missing, tell the user and stop.
  3. List the module folder and ask the user to confirm the course is theirs to adapt and translate, and that the presenters agree to their names and titles being localized. Stock photos or partner logos credited on end cards may have their own terms; list them as rows, do not clear them.

Asking for the rights confirmation was not exercised in our test run, which used public Creative Commons licensed course videos.

Done when the connector shows write access, ffmpeg and ffprobe run, and the user has confirmed the folder and the rights.

Step 2: Measure the modules and price the job

Goal: the user approves the index minutes and search credits before anything is spent.

  1. Measure each file:
ffprobe -v error -show_entries format=duration -of csv=p=0 MODULE_FILE

MODULE_FILE is one file from the module folder; run it once per file and add up the seconds. 2. Call vivu_get_usage for the plan and what remains this month. 3. Show one table. Search credits: one precise search per category (a precise search uses 5 credits in total), so the five default searches are 25 credits, an estimate that grows if a wording is retried. The searches run once per course, not every month.

This course Plan allowance Remaining
Index minutes measured total from vivu_get_usage from vivu_get_usage
Search credits estimate from vivu_get_usage from vivu_get_usage

For reference, Free is 20 index minutes a month and 50 search credits a month; Premium is $30 a month with 180 index minutes a month and 500 search credits a month. 4. If it does not fit, offer levers that shrink what is indexed, in this order: index two or three representative modules first (title cards and diagram styles usually repeat across modules, so the motion designer can start), then the rest next month; drop categories the user does not need. Moving to a larger plan comes last. Never drop modules the user asked for without saying so.

The approval itself was not exercised in our test run; measuring with ffprobe and reading vivu_get_usage were.

Done when the user has approved the minutes and credits in writing.

Step 3: Create the project and upload

Goal: every module is in one private Vivu project and shows ready.

  1. Call vivu_list_projects and reuse the course's project if the user named one. Otherwise call vivu_create_project with name "Localization COURSE_NAME" and visibility "private" (COURSE_NAME is the course title). The default visibility is visible to the whole organization, and unreleased course material should not be.
  2. Call vivu_open_upload_page with the project_id. The upload_url expires in 180 seconds, so request it right before use and never paste it into a file or message. Give it to the user to open in their own browser and select the module files, or attach the files with a browser tool that can attach local files (Claude in Chrome takes at most 10 MB per upload call). Files above that limit go through the user's browser or the Vivu web app. Never split or recompress a module to fit, because the sheet's timestamps must match the user's files.
  3. Poll vivu_list_videos every 30 seconds or so until every video shows ready. Vivu replaces spaces and brackets in file names with underscores; record in config.json which Vivu file_name and video_id belong to which local file.

Uploading through the user's own browser or a browser tool was not exercised in our test run; the files went in through a separate scripted upload to the same upload page, and polling to ready was exercised.

Done when vivu_list_videos shows every module as ready and config.json maps each video_id to a local file.

Step 4: Search once per kind of on-screen text

Goal: one raw result file per category.

Each query describes the kind of graphic, not its words. Writing the expected wording into a query invites the reason text to claim that wording on a different graphic.

Field Query Mode
title_card a full screen title card or end card that opens or closes a lesson video, showing the course or module name, the presenter credit, or end credits and license text precise
diagram a diagram, flowchart, cycle, chart or map on screen whose boxes, arrows or regions carry text labels precise
name_strip a lower third caption over a person on camera showing their name and job title precise
callout an arrow or tag with a few words added on top of a screen recording to point at part of the software interface precise
bullet_slide a slide with a heading and a bulleted list of key points precise
ui_text no search; listed from the Step 6 sweep local

How the pieces connect: each search returns candidate windows for one kind of graphic, so Step 5 extracts frames inside those windows to confirm the graphic and later read its wording; because windows merge repeated graphics and miss short ones, Step 6 sweeps every module locally to catch what the searches did not return. There is no search on the narration: presenters rarely read a title card or diagram label out loud, and this sheet only lists what is in the picture.

Title cards and diagrams are the reliable searches. Callouts are not: the callout search mostly returned highlight boxes with no words and buttons that belong to a web page, and its reason text described arrows and tags that the frames do not show (numbers in Step 5). Treat callout and bullet slide windows as leads for the frame check, never as rows. Matching graphics by description is rated weak across other Vivu tests (it finds the right thing but can skip some), which is the second reason the local sweep in Step 6 is not optional.

Run each with vivu_search_videos (project_id, query, mode "precise", maximum_results 40). Precise is the only mode that returns a time window; fast returns whole files with an empty reason, so it cannot place a title card. maximum_results 40 because it is also the ceiling on how many windows come back, and a course has many slides of the same kind; raise it for a long course. vivu_get_search_results returns when the job is complete; each status call can wait up to 45 seconds, so keep calling while complete is false, and a pending search is not a stalled one. Save each completed response as results/CATEGORY.json and record the job_id in state.json. Show the Vivu result page link in your reply if the user wants to browse; it expires after four hours, so it never goes into the CSV or any saved file.

Done when every chosen category has a saved raw result file.

Step 5: Check every window against the user's files

Goal: candidates.csv with every window marked verified or false positive.

For each window, map video_id to the local file and extract three frames: start, middle and end of [start_ms, end_ms] (SECONDS is milliseconds divided by 1000):

ffmpeg -v error -ss SECONDS -i MODULE_FILE -frames:v 1 -q:v 3 frames/CATEGORY_hN_POS.png

N is the window number in the result file, POS is start, mid or end. Look at each frame. A window is verified when at least one frame shows a graphic of the asked kind; otherwise it is a false positive. When none of the three frames is clear, make a 0.5 s strip across the window before deciding:

ffmpeg -v error -ss START_SECONDS -to END_SECONDS -i MODULE_FILE -vf "fps=2,scale=320:-1,tile=6x5" frames/CATEGORY_hN_strip_%02d.png

START_SECONDS and END_SECONDS are the window edges in seconds; each tile is half a second after the previous one, so tile k sits at about START_SECONDS + k / 2. The tile can show a slightly later moment than that arithmetic says, so confirm any time that goes into the sheet on a single extracted frame.

A second window on the same graphic is a duplicate: keep it in candidates.csv, list the graphic once. Count false positives and tell the user the number per category.

Worked example from our test run

In our test run we used 6 public course videos (23.25 minutes in total): Creative Commons licensed modules from an open source software course and from a university MOOC, with title and end cards, slides, flowcharts, a map, a presenter lower third, and arrow tags added over a screen recording. From the start of the upload to every video ready took about 7 minutes. Each search ran once with the wording in the Step 4 table, with no rewording. The title card search returned 7 windows, 7 real and 0 false, and missed 2 of the 9 cards in the course; both misses were short end cards. The diagram search returned 7 windows, 7 real and 0 false, with 0 diagrams missed; several windows were duplicates on a flowchart another window already covered. The name strip search returned 2 windows: 1 real lower third and 1 false (a name printed under a photo on a title slide). The callout search returned 5 windows, 1 real and 4 false: the real one was a single long window over every arrow tag in the module, and the false ones were highlight boxes with no words and parts of web pages. The bullet slide search returned 7 windows, 6 real and 1 false (a course web page), and missed 1 slide. A timeline search, used as a control because the course has no timeline, returned 0 windows. Getting the user's approval of the price and the sample row was not exercised in our test run, because the factory run has no user to ask.

Done when every window in every raw file has a row in candidates.csv marked verified, duplicate or false positive.

Step 6: Sweep each module for what the searches missed

Goal: every text graphic in the course is either in candidates.csv or added from the sweep.

The searches merge repeated appearances into one window and miss short ones, so sweep every module once with a 2 s contact sheet (30 frames per sheet, one minute per sheet):

ffmpeg -v error -i MODULE_FILE -vf "fps=1/2,scale=320:-1,tile=6x5" sheets/MODULE_NAME_%02d.png

MODULE_NAME is the file name without extension. Tile k on sheet n is at about (n - 1) * 60 + 2 * k seconds. Look at every sheet, write down each title card, diagram, name strip, callout, bullet slide and screen recording section that has no verified window, and add it to candidates.csv as source "sweep". Software interface text inside screen recordings (ui_text) comes only from this sweep; list one row per screen the presenter points at, not every label in the interface. Anything on screen for less than 2 seconds can fall between tiles; when a module has fast animated text, sweep that module again at fps=2.

In our test run the sweep found all 3 missed graphics: the short end cards and a bullet slide that no window reached. We looked at every sheet that held a miss and a sample of the others, not every sheet, so a full sweep of every sheet was not exercised in our test run; the ui_text rows were not exercised in our test run either.

Done when every sheet has been looked at and candidates.csv has the sweep rows.

Step 7: Pin the times, read the text, and write the sheet

Goal: onscreen_text.csv with one row per distinct graphic, wording read from a full frame.

  1. For each verified or sweep graphic, find its first and last frame with a 0.5 s strip around the window or sheet tile (the command in Step 5) and write start and end as MM:SS.
  2. Extract one full size frame where the graphic is complete and read the wording from it:
ffmpeg -v error -ss SECONDS -i MODULE_FILE -frames:v 1 frames/read_MODULE_NAME_SECONDS.png

Copy the wording exactly, line breaks as " / ". If any part is too small or blurred to read, write what is legible and put UNCERTAIN in notes rather than guessing; the translator checks those rows against the frame. 3. Merge duplicates: one row per graphic per appearance; a graphic that stays on screen across one window is one row. 4. Show the user one sample row and the field mapping, and wait for a yes before writing the whole sheet:

module_file,start,end,category,original_text,frame,translation,redo_method,status,notes
module05.mp4,04:24,04:30,callout,"Module 7",frames/read_module05_268.png,,,verified,red arrow tag slides in from the right over the settings page
Field Source If unavailable
module_file local file name from config.json none
start, end first and last 0.5 s frame showing the graphic the window edges, marked UNCERTAIN
category the query or the sweep that found it none
original_text read by Claude from the full frame UNCERTAIN, partial text
frame path of the read frame none
translation, redo_method left empty for the translator and the motion designer empty
status verified (search window checked) or sweep (found by the contact sheet) none
  1. Before writing, open the frame named in each row and confirm the text is in it; re-extract any row whose frame came from a contact sheet tile or a different window.
  2. Write onscreen_text.csv and tell the user how many rows per category, how many came from the sweep rather than the searches, and how many rows are UNCERTAIN.

In our test run, wording read from full frames matched a second read from enlarged crops of the smallest text (a map legend, a cycle diagram), while a wording first read from a small contact sheet tile dropped a plural and had to be corrected from the full frame. That is why original_text should come only from full frames. Our first pass of the sheet did not hold to this: several rows (the later arrow tags in one module, two bullet slides and one end card) were read from contact sheet tiles or from a frame of a nearby window, and one of those frames did not show the tag at all. A review caught it, and we then pulled a full frame for each of those rows before calling the sheet done; check the frame column the same way, since a row whose frame does not show its text has not been read. License paragraphs at the bottom of title cards were too small to read at 720p and went in as UNCERTAIN. Pinning start and end with the strip was done for a single row; the other rows kept times from a coarser contact sheet, so pinning every row was not exercised in our test run.

Done when the user has approved the sample row and onscreen_text.csv exists with one row per graphic.

Compliance

  1. Localize only courses the user's organization owns or has the right to adapt and translate. Have the user confirm this in Step 1, before anything is uploaded.
  2. Presenters' names and titles on name strips get changed in the localized version; the presenters should agree to that (confirm in Step 1).
  3. Third party material credited on end cards (stock photos, partner logos) may have its own terms for reuse in a new language version. List it; clearing it is the user's job.
  4. The modules stay in the user's Vivu project until the user deletes them. Create the project as private (Step 3); the default is visible to the whole organization. This skill never deletes projects or videos.
  5. The skill reads text graphics. It does not identify people, faces or logos, and it does not produce subtitles or translations.

Known failure modes

Symptom Cause Fix
(observed) callout windows show highlight boxes with no words or a web page's own buttons, while the reason says "Red arrows appear on top of the screen recording" the callout search matches any arrow, box or button over a screen recording, and the reason describes what the query asked for judge from the frames only; keep tags that carry words. In our test run the callout search returned 5 windows and 4 were false
(observed) an end card or license card is missing from the sheet cards on screen for a second or two were not returned; in our test run the title card search missed 2 run the Step 6 sweep every time; an empty search result does not prove the course has no such card
(observed) a name under a photo on a title slide comes back as a name strip, with a reason placing it "below the video feed of the speaker" the search does not tell a slide caption from a lower third over a person on camera check the frames; list it under the title card it belongs to
(observed) a web page with a bulleted list comes back as a bullet slide web pages shown full screen look like slides to the search check the frames; list web pages as ui_text if the user wants interface text
(observed) one window covers every arrow tag in a module, and its start, middle and end frames show no tag at all tags appear for a few seconds each inside a long window run the Step 5 strip command across the window and write a row per tag
(observed) a wording in the sheet drops or changes a word it was read from a small contact sheet tile or taken from the reason text read original_text only from a full size frame
(observed) small license or credit text cannot be read footnote sized text at 720p write the legible part, mark UNCERTAIN, and pull a frame from the highest resolution master
upload page asks to sign in or shows an error the one time upload link expires after 180 seconds request a new link right before opening it
"has not granted vivu.write" Vivu connected read only the user reconnects Vivu with write access
a file is rejected by the browser upload tool the tool accepts at most 10 MB per upload call the user adds that file in their own browser or the Vivu web app; never recompress it
result file names do not match the module files Vivu replaces spaces and brackets with underscores map video_id to the local file through config.json
the reason text quotes words that are not on the card the reason paraphrases and can describe text that is not on screen never copy wording from the reason; read the frame

Connect Vivu, then add the skill.

The skill runs through the Vivu connector. Add it to Claude from the connector directory, then install the skill.