Youth game highlight reel

---
name: youth-game-highlight-reel
description: "Turn your own video of your kid's basketball game into a highlight reel with Vivu: made basket candidates checked on frames, you pick your child, ffmpeg joins the clips. Use after a game."
---

Youth game highlight reel with Vivu

This skill turns a parent's own video of their child's basketball game into a short highlight reel of the child's baskets. The parent gives Claude the game file (or the few files a phone makes when recording stops and starts). Claude measures it and prices it against the parent's Vivu plan, uploads it to a private Vivu project, runs one search of the whole game for made baskets, checks each candidate on a contact sheet and on frames at the rim, and cuts a short preview of each basket it can confirm. The parent watches the previews and marks the ones that show their child. Claude cuts those moments from the original file and joins them into highlight_reel.mp4, which the parent watches and shares with the family themselves.

The value is in the footage itself. A phone video from the stands has no transcript, no chapters and no stats, and youth leagues rarely publish a play-by-play, so the only record of when a basket happened is the picture. Scrubbing a whole game for a minute of highlights takes an evening; here the parent only looks at short previews. The skill does not try to find the child by jersey number or by face. In our test run a search for a jersey number returned mostly other players, and the number could not be read in a wide shot even when zoomed in (numbers in the worked example). So Vivu finds basket moments for the whole floor, Claude throws out the ones that are not baskets, and only the parent decides which baskets are their child's.

When to use

Use when a parent asks to make a highlight reel of their kid from a game they filmed, to pull out all the times their child scored, or to turn last night's game video into a clip for the family group chat.

Not for these:

1. Other people's children. A coach, a club or a fan wanting reels of players needs each family's consent; this skill is for a parent or guardian and their own child.
2. League or school livestream recordings. Check that platform's terms first; this skill is written for video the parent filmed.
3. Finding a player by jersey number or face. The skill does not do it and the numbers below show why.
4. Misses, steals, blocks or passes. Only made baskets are searched. The parent can add any moment they remember by time (Step 6).
5. One question about one moment ("when did she hit the three?"): scrub the video or search Vivu directly.

Working principles

1. Report measured numbers, not estimates. When a number is an estimate, say so.
2. Nothing is "verified" until it has been checked against the source video. Vivu's results are candidates; a candidate reaches the reel only after Claude has seen a made basket (or marked it can't tell) on the frames and the parent has said it shows their child. Rejected candidates stay in candidates.csv and never reach the reel.
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 (indexing the game) and before the reel is final (the parent watches it). The skill sends and posts nothing; if the parent later asks Claude to send the reel somewhere, name the destination and ask again first.
5. Never decide who is in a clip. Claude may say "the number reads 25 in this frame" when it is plainly readable, but the parent makes every pick. Vivu's reason text is not evidence of who shot or whether it went in.
6. Times in every file are times in the parent's own video file, so the parent can check any clip themselves. A Vivu result page link expires after four hours, so it appears only in the live reply.

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.

This skill needs Claude Code on the user's computer (the terminal or the Code tab of Claude Desktop), because it reads and cuts local video files. Claude on the web and cloud sessions cannot reach them. It downloads nothing, so no residential IP is needed, and nothing recurs, so no scheduler is involved; run it once per game.

Inputs to collect

Ask for anything missing, most important first.

1. GAME_FILE: the path to the game video. Required. If the phone made several files, list them all; each becomes its own video in Vivu. GAME_NAME is GAME_FILE's name without the extension, spaces or brackets; it names the working folder.
2. Which parts to index. Default: the whole file. A parent who knows the child sat out a half can index only the parts the child played (Step 2).
3. The two teams' combined final score. Default: ask; it sets maximum_results in Step 4. If nobody knows, use 100.
4. The child's jersey color and number. Optional, and used only for Claude's hints in Step 6, never to pick clips.
5. Clip padding. Default: each clip starts 4 seconds before the ball reaches the rim and ends 3 seconds after.
6. Order of the reel. Default: game order.

Files and state

Keep everything in one working folder next to the video:

reel-GAME_NAME/
  config.json          GAME_FILE(s), parts indexed, final score, jersey hint, padding, Vivu project id
  state.json           steps done, uploaded video ids, candidate keys judged, picks, clips cut
  results/made_basket.json   the search result as returned, without result_page_url
  sheets/cand_NN.png   one contact sheet per candidate
  frames/              full frames and zoomed frames at the rim
  previews/cand_NN.mp4 one short preview per candidate that shows a basket or can't tell
  candidates.csv       every candidate: Claude's check, the note, sheet, preview, hint, the parent's pick
  clips/clip_NN.mp4    the picked clips, plus list.txt for joining
  clips.csv            one row per clip in the reel
  highlight_reel.mp4   the finished reel

A rerun reads state.json first and skips finished steps. A file already uploaded is never uploaded again; a candidate key (video_id plus start_ms) already in candidates.csv is not judged again; a clip already cut is not cut again. Each game gets its own folder and its own Vivu project.

Step 1: Check the Vivu connector, the tools and who is asking

Goal: the connector works, the tools are there, and the user may use this skill for this video.

1. Call vivu_get_account. If the tool is missing, tell the user to add the Vivu connector in Claude (https://mcp.vivu.ai/mcp) and stop. It must return an account with can_create_projects: true. If a write call later fails with "has not granted vivu.write", ask the user to reconnect Vivu and allow write access.
2. Run ffmpeg -version and ffprobe -version. If either is missing, tell the user and stop.
3. Ask: "Are you the parent or legal guardian of the child you want the reel of, and did you film this video yourself?" If not, stop and explain that the skill only works for a guardian and their own footage. Also say that other children are in the footage, so the reel is for the family, and anything public needs the other families' consent and the team's filming rules. The guardian question was not exercised in our test run, which used adult players.

Done when vivu_get_account shows can_create_projects: true, both tools print a version, and the user has confirmed they are the guardian and filmed the video.

Step 2: Measure the game and price it

Goal: the parent approves how many index minutes this game will use.

1. Measure each file:

ffprobe -v error -show_entries format=duration -of csv=p=0 GAME_FILE

Index minutes = the sum of the durations divided by 60, rounded up.

2. Call vivu_get_usage and read the plan and what remains this month.
3. Show one table, labeling estimates:

Plan facts for reference: Free is $0 a month with 20 index minutes a month and 50 search credits a month; Premium is $30 a month with 180 index minutes and 500 search credits. A precise search uses 5 credits in total. A whole youth game with breaks often runs 40 to 60 minutes (estimate), so the Free plan does not cover a full game and Premium covers a few games a month.

4. If the game does not fit, offer these levers in order, each with the minutes it saves, and let the parent choose:
   1. Index only the parts where the child played. Ask which periods; cut each part without re-encoding, and later cut clips from these same part files so Vivu's times match:

ffmpeg -v error -ss PART_START -to PART_END -i GAME_FILE -c copy GAME_NAME_part_P.mp4

  PART_START and PART_END are seconds in GAME_FILE and P numbers the part. Cutting parts was not exercised in our test run.

2. Leave out long breaks (warmups, halftime) the same way.
3. Move to a larger plan.

Never drop parts of the game the parent asked for without saying so.

The account used in our test run returns no allowance figures, so the comparison with a real plan and the parent's approval were not exercised in our test run. If vivu_get_usage returns no remaining figures, show the minutes and credits anyway and ask the parent to confirm their allowance.

Done when the parent has approved the files and minutes to index, recorded in config.json.

Step 3: Create a private project and upload

Goal: every approved file is ready in Vivu.

1. Call vivu_create_project with name "Highlights GAME_NAME", a short description, and visibility "private". The default is visible to everyone in the user's Vivu organization, which is wrong for video of children. Record the project id in config.json.
2. Call vivu_open_upload_page with the project id. It returns upload_url, a one time sign in link that expires in 180 seconds, so request it right before use, never paste it into a file or a message, and request a new one if it lapses.
3. Give the link to the parent at once and ask them to open it in their own browser and choose the files. Phone videos are far larger than browser tools accept (Claude in Chrome takes at most 10 MB per upload call), so the parent's own browser is the normal path. If a file will not go through, the parent adds it in the Vivu web app. Never split or recompress a video to make it fit.
4. Poll vivu_list_videos every 30 seconds or so until every file shows ready, and record each video_id in state.json. Vivu replaces spaces and brackets in file names with underscores, so match each result back to the local file by its name after making the same replacement.

In our test run a single quarter was ready 5 minutes after the upload started. Our test upload did not go through a browser, so the parent's browser upload was not exercised in our test run.

Done when vivu_list_videos shows every approved file as ready and state.json lists their video ids.

Step 4: Search for made baskets

Goal: a list of candidate made baskets for the whole floor.

Run vivu_search_videos with project_id, that query, mode "precise" and maximum_results. Precise is the only mode that returns time windows; fast returns whole files and would not help here. maximum_results is also the most candidates Vivu will return, so a basket beyond that number can never reach the reel. The combined final score is roughly twice the number of made baskets (a rule of thumb, estimate), which leaves room for false candidates. In our test run we set maximum_results to 30 rather than the combined score and 29 candidates came back, so the cap did not cut the list; setting it from the combined final score was not exercised in our test run.

The search returns a job ID. Call vivu_get_search_results until complete is true; each call can wait up to 45 seconds, so a pending search is not a stalled one. Save the complete result to results/made_basket.json with its result_page_url field removed. Show the Vivu result page link in the reply once and say it expires after four hours; never put it in a file.

Vivu is weak at this: in our test run most candidates were not made baskets and some baskets were missed (numbers in the worked example under Step 5). That is why Step 5 checks every candidate on frames and Step 6 asks the parent for baskets the list missed.

The chain is one search and two checks: the precise search finds the basket windows, the contact sheet and the frames at the rim confirm that a basket happened, and the parent's look at the preview confirms whose basket it was. A fast search first would not help, because a game is one file or a few, and fast only picks files. There is no second query for what is said either: a phone video's sound is crowd noise, so the search looks only at the picture.

This wording is the one we tested. A reworded query is untested until its candidates have been through Step 5.

Done when results/made_basket.json exists and holds the complete result without result_page_url.

Step 5: Check every candidate on a contact sheet

Goal: every candidate marked made basket seen, no made basket, or can't tell, with the frames behind it.

1. For candidate N (numbered in the order Vivu returned them; NN is N written with two digits), GAME_FILE is the local file whose name matches the result's file_name, START is start_ms / 1000, SECONDS is (end_ms minus start_ms) / 1000 and ROWS is SECONDS times 2 divided by 5, rounded up. Make a contact sheet at two frames per second:

ffmpeg -v error -ss START -t SECONDS -i GAME_FILE -vf "fps=2,scale=320:-2,tile=5xROWS" -frames:v 1 sheets/cand_NN.png

Cell k, counted left to right and top to bottom from 0, is second START plus k / 2. One frame is not enough: the window is wider than the shot, and the basket can sit anywhere in it.

2. Find the shot on the sheet. Then look at full frames around the moment the ball reaches the rim, every half second, and zoom the half of the frame that holds the basket. T is the second in GAME_FILE to look at; HALF_X is 0 for the left half and iw/2 for the right half:

ffmpeg -v error -ss T -i GAME_FILE -frames:v 1 -q:v 3 frames/cand_NN_T.png
ffmpeg -v error -ss T -i GAME_FILE -frames:v 1 -vf "crop=iw/2:ih/2:HALF_X:0,scale=iw*2:-2" -q:v 3 frames/cand_NN_T_zoom.png

3. Judge each candidate:
   1. made basket seen: the ball drops through the net, and after it the other team takes the ball out from under that basket (a shot clock, if the gym has one, resets).
   2. no made basket: the ball bounces out, free throws miss, there is no shot, or the basket happened before the window.
   3. can't tell: the camera looked away or the rim is hidden. These go to the parent too, labeled.
4. For each made basket seen or can't tell, cut a short preview for the parent. START and END are the window's seconds; for a window longer than 20 seconds, use the 20 seconds around the basket instead:

ffmpeg -v error -ss START -to END -i GAME_FILE -vf scale=-2:480 -c:v libx264 -preset veryfast -crf 23 -c:a aac previews/cand_NN.mp4

5. Write every candidate to candidates.csv, including the rejected ones, and tell the parent how many were checked, how many showed a basket, how many were rejected and how many were can't tell.

Sample row (placeholder values):

game_file,cand_no,start_s,end_s,start_mmss,claude_check,claude_note,sheet,preview,shooter_hint,parent_pick
GAME_2026-03-14.mp4,3,970.0,980.0,16:10,made basket seen,layup at the rim at 976.5 s,sheets/cand_03.png,previews/cand_03.mp4,number not readable at the shot,

Show the parent this sample row and the field mapping before writing the rest. There was no parent in our test run, so this approval was not exercised.

Worked example from our test run

In our test run we used a single public recording of a college women's game where every player is an adult (we did not test on footage of children): the whole first quarter, 18.75 minutes, filmed mostly by a wide camera high in the stands that follows the ball, with a second camera cutting to close shots of the scorer after some baskets. We removed the sound. It was a school's broadcast recording, not a phone video, so phone footage is untested. It was ready in Vivu 5 minutes after the upload started.

The made basket search in the table (the first wording, no rewording) returned 29 candidates and took about 6 minutes to complete. After an independent second judge and an arbiter checked every window on the frames, 12 were real made baskets and 17 were false, a false positive rate of 59%, and 7 of the quarter's 19 made baskets were missed. Most false candidates held a shot that missed or free throws that missed.

We followed two players from the official play-by-play. For the player in white, each of her made baskets in the quarter was among the real candidates. For the player in dark, most of her made baskets were not among the candidates.

Searching by jersey number, which this skill does not do: the wording we settled on after 1 rewording on the same corpus asked for the dark player's number to be clearly readable. It returned 18 windows: 1 real, 12 false and 5 unjudged, where neither judge could read the shooter's number even zoomed in, and it missed 4 of her 5 shots. The same wording for the player in white returned 20 windows: 1 real and 19 false, with 4 of her 5 shots missed. Vivu's reason text named the requested number on false windows too, including a close shot of a player wearing a different number.

At the moment of each shot we checked, the shooter's number could not be read in the full wide frame. Numbers were readable only in the broadcast's close shots after some baskets, which a phone video from the stands will not have. That is why the parent, not Claude, decides which candidates show their child.

Done when every candidate has a row in candidates.csv with a check of made basket seen, no made basket or can't tell, and each made basket seen or can't tell row names a sheet and a preview that exist.

Step 6: The parent picks their child

Goal: the parent has marked each preview mine or not mine.

1. Give the parent the previews/ folder and the list of made basket seen and can't tell rows in game order, with the time in their own file (start_mmss).
2. The parent watches each preview and answers mine or not mine. Parents recognize their child by far more than a number (how she runs, her hair, where she plays); Claude does not.
3. Claude may add a hint to a row, only from what a frame plainly shows (for example "the number reads 25 in the close shot after the basket"), and says "number not readable" otherwise. A hint never marks a pick.
4. Ask whether the parent remembers a basket that is not in the list. Missed baskets are common (see the worked example). For each time they give, make a sheet and a preview around it as in Step 5 and add it as a new candidate.
5. Write each answer to parent_pick in candidates.csv. Rows the parent did not answer stay blank and do not reach the reel.

In our test run there was no parent: the pick was simulated from the official play-by-play, so the parent's own review was not exercised in our test run.

Done when every made basket seen or can't tell row has a parent_pick of mine or not mine, and the parent has said whether any basket is missing.

Step 7: Cut the clips and join the reel

Goal: highlight_reel.mp4, approved by the parent.

1. For each row marked mine, in game order, RIM is the second the ball reached the rim (from the Step 5 frames). CLIP_START is RIM minus the padding before (default 4) and CLIP_END is RIM plus the padding after (default 3). Cut from the same file that was uploaded, so the times match, and re-encode so the cut lands exactly:

ffmpeg -v error -ss CLIP_START -to CLIP_END -i GAME_FILE -c:v libx264 -preset veryfast -crf 20 -c:a aac clips/clip_NN.mp4

2. Write clips/list.txt with one line per clip in order, for example:

file 'clip_01.mp4'
file 'clip_02.mp4'
file 'clip_03.mp4'

3. Join them without re-encoding again, then check the length:

ffmpeg -v error -f concat -safe 0 -i clips/list.txt -c copy highlight_reel.mp4
ffprobe -v error -show_entries format=duration -of csv=p=0 highlight_reel.mp4

4. Write clips.csv (game_file, clip_no, start_s, end_s, start_mmss, cand_no, rim_s, claude_check, parent_pick, source_window_ms) and update state.json.
5. Ask the parent to watch highlight_reel.mp4 from start to end before sharing it. Fix any clip they want trimmed or dropped and join again. Remind them that the reel shows other children, so it is for the family; anything public needs the other families' consent. The skill does not send the reel anywhere; the parent shares it.
6. When the parent is done, ask whether to keep the game in Vivu. If they want it removed, confirm first, then call vivu_delete_video for each file. Otherwise it stays in their private project until they delete it.

In our test run the clips and the join ran as above and produced the reel; the parent watching and approving it was not exercised in our test run.

Done when highlight_reel.mp4 exists, ffprobe prints its length, clips.csv has one row per clip, and the parent has said the reel is ready to share.

Compliance

1. Guardian and own footage. The skill is only for a parent or legal guardian making a reel of their own child from video they filmed. Ask in Step 1 and stop otherwise.
2. Other children. Game video shows other people's children. Keep the reel within the family. Posting it publicly needs the other families' consent and must follow the team's, league's or school's filming rules; say this in Step 1 and again when the reel is done.
3. No identification. The skill does not recognize faces or read identities. Vivu finds basket moments; the parent says which ones show their child.
4. Where the video goes. The game stays in the parent's own Vivu project, created as private in Step 3, until they delete it (Step 7 offers). Nothing is posted or sent by the skill.
5. Recordings the parent did not make (a league stream, a school broadcast) are out of scope; their platform's terms and usage rights apply.

Known failure modes