SkillsSkill for Claude

Product list for your video description

A creator hands over one to three of their own unboxing, review or favorites videos and a rough product list, and gets back a product list for the description: when each product first appears, the brand and model text read from a frame of the box (blank when nothing readable is printed), a line from the transcript, a chapter line and an empty link column. Claude prices the indexing, indexes the files in a private Vivu project, runs one speech search per product and one search for items held up to the camera, checks every window against the transcript and the frames, and writes the CSV and a description block. The value is in what the transcript leaves out: creators say "the next thing I got is this", captions mishear brand names, and the draft list forgets the adapter that came in the box.

Maintained by Vivu. Updated 2026-11-19.

Download

video-description-product-list.zip

10 KB. Unzips to video-description-product-list/SKILL.md. Upload the zip as it is in the Claude app, or unzip it into your skills folder for Claude Code.

SHA-256 fb5071dab697e915f822dd02b1b5e4aefc0cd75a9f0c0a675d708949e05a25cb

At a glance

What the Product list for your video description skill does, where it runs, what it needs, and when it asks
Looks forThe stretch where the creator introduces each listed product, the frame where its box or label faces the camera, and items held up to the camera that are missing from the list. The model name exists only in the picture, and every window is checked against the transcript or the frames before it reaches the list.
Runs onClaude Code on your computer (the terminal or the Code tab of Claude Desktop), because it reads your local video files and runs ffmpeg. No residential IP is needed, since nothing is downloaded, and nothing is scheduled. The only connector it needs is Vivu.
Needs
  • The Vivu connector with write access, to create a private project, open its upload page and search.
  • A shell with ffmpeg and ffprobe, to measure the videos and extract frames.
  • Your videos as local files, the same edit viewers will see, so chapter times match.
  • A transcript per video (an .srt or .vtt, or a local speech to text tool), because intro lines are copied from it.
  • Your draft product list per video; rough names are fine.
  • A way to upload: the Vivu upload page in your own browser, or a browser tool that can attach local files.
Your Vivu planIndexing uses the total length of the videos in index minutes, and each product on your list costs one precise search plus one more search per batch for items held up to the camera. The skill shows the minutes and credits against your plan before anything is uploaded. Our test run indexed 24.78 minutes.
Asks you firstBefore uploading (the minutes and credits), before writing the full list (one sample row and the field mapping), and before posting the description or putting it anywhere outside the working folder.

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 your own videos; it does not import platform links or other channels' uploads.
  • People on camera should have agreed to the published video, and videos with children need the consent you hold to cover storing them in a private Vivu project.
  • You write your own affiliate or gifted product disclosure; the skill leaves a reminder line and does not judge platform rules.
  • The search for items held up to the camera is a candidate source: in our test run it found the microwave splatter cover we left off the list but missed the power adapter we also left off, so the list still depends on your draft.
  • First appearance times come from search windows and can be late when the box is shown early in the intro; those rows are checked or marked UNCERTAIN.
  • Model text is read only from frames; small or glary labels stay blank rather than guessed, and captions are never used for model names.
  • Claude in Chrome uploads at most 10 MB per call; larger videos go through the upload link in your own browser or the Vivu web app.
  • Your videos stay in your Vivu project until you delete them.
  • Posting the description or editing the video acts as you, so the skill asks first and by default leaves posting to you.

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:

Here are my last three unboxing videos in ~/Videos/exports and my rough product list for each. Make the product list for the descriptions: when each thing first shows up, the model off the box, chapter lines, and empty link slots.

In Claude Code you can also type /video-description-product-list. 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 and price the job
  8. Step 3: Upload and index
  9. Step 4: Search
  10. Step 5: Check the speech windows
  11. Step 6: Check the camera windows and find what the list missed
  12. Step 7: Read the model text and set first seen
  13. Step 8: Write the list and the description block
  14. Compliance
  15. Known failure modes

The full skill

This is video-description-product-list/SKILL.md from the download, as Claude reads it: the frontmatter first, then the instructions.

---
name: video-description-product-list
description: "Build the product list for your video description with Vivu: when each product first appears, the model read off the box, a chapter line and an empty link column. Use before you publish."
---

Product list for your video description

This skill takes one to three of a creator's own unboxing, review or favorites videos (the local exports) and the creator's draft list of products, which is usually incomplete, and returns a product list for the description: one row per product with the episode and source file, the time it first appears as MM:SS, the brand and model text read from a full frame of the packaging or the product (blank when nothing readable is printed), one line copied from the local transcript where the creator introduces it, the frame path, a chapter line in the form "MM:SS Product name", and an empty buy_link column. Claude prices the indexing against the user's Vivu plan, indexes the files in a private Vivu project, runs one speech search per product on the list and one search for items being shown to the camera, checks every window against the transcript and against frames, reads the model text from frames, and writes product_list.csv and a description block. The creator fills in the links and pastes the block into the description.

The value is in what the transcript leaves out. Creators say "the next thing I got is this" and "this one", and the product name sits only on the box, on the product, or on a card the editor added. Auto captions mishear brand names, so a model name copied from captions can come out wrong. And the draft list misses things: the power adapter that came in the box, a small extra item the creator unwrapped between two others. So the speech search finds where each listed product is introduced, the frames decide what the product is called, and a second search for things held up to the camera looks for items the list forgot. Nothing reaches the list without a transcript line or a frame that shows it.

When to use

Use when a creator asks "make the product list for my description from these two videos", "what time does each product show up in this haul, I need chapters", "read the model names off the boxes so I can add affiliate links", or "check whether I forgot any product in my list for this episode".

Not for these:

  1. One question about one video ("when do I open the charger?"): search Vivu directly or scrub the video.
  2. Proving a sponsor read to a brand. The sponsor-read-proof-sheet skill (https://vivu.ai/skills/sponsor-read-proof-sheet) does that.
  3. Live shopping replays with a pin log. The live-shopping-product-index skill (https://vivu.ai/skills/live-shopping-product-index) indexes those.
  4. Picking a thumbnail frame. The thumbnail-frame-candidates skill (https://vivu.ai/skills/thumbnail-frame-candidates) does that.
  5. Someone else's videos or a platform link. This skill reads only the creator's own local files.
  6. Finding buy links, writing affiliate disclosures or posting the description. The creator does those.
  7. Planning B-roll before the edit (which mentions still need a shot). This skill works on the finished video for its description.

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 video. A speech window is a candidate until the transcript shows the creator talking about that product; an item from the camera search is a candidate until a frame shows it. Vivu's reason text paraphrases and can name text that is not on the box, so it never fills a cell.
  3. Model text comes only from a full frame. When the frame does not show it clearly, the cell stays blank and says why; a wrong model in a description sends viewers to the wrong product.
  4. Stop and tell the user when a required capability or tool is missing. Do not guess around it.
  5. Ask the user before anything that is expensive to redo (the indexed minutes, before upload) and before anything that acts on their behalf. The skill writes local files only; the creator adds the links and publishes.

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 user reconnects Vivu and allows write access
A shell with ffmpeg and ffprobe measure the videos, make contact sheets, extract frames ffmpeg -version, ffprobe -version
The videos as local files, the same edit the viewers will see Vivu indexes uploads, frames are read from the user's copy, and chapter times must match the published video ls VIDEO_DIR shows the files; the user confirms they are the final exports
A transcript per video: the .srt the editor exported, captions the creator downloaded for their own upload, or a local speech to text tool such as whisper.cpp the intro line is copied from the transcript, and speech windows are checked against it an .srt or .vtt per video, or whisper-cli --help
The creator's draft product list, one line per product per video (a rough name is fine) each product gets its own speech search the user pastes it
An upload path move the videos into Vivu vivu_open_upload_page plus the user's own browser, or a browser tool that can attach local files

This skill needs Claude Code on the user's computer (the terminal or the Code tab of Claude Desktop), because it reads local files and runs ffmpeg. It downloads nothing from YouTube or other sites, so no residential IP is needed. Nothing recurs, so no scheduler is involved; run it once per batch of videos. The only connector it needs is Vivu.

Inputs to collect

Ask for anything missing, most important first.

  1. VIDEO_DIR: the folder with the exported videos. Required.
  2. The draft product list for each video. Required. A rough name per product is enough ("pink soap dish", "the ESR charger").
  3. The transcript files. Default: look for an .srt or .vtt next to each video with the same name; otherwise ask whether to run the local speech to text tool.
  4. WORK_NAME: a short name for the working folder and the Vivu project. Default: the month and "products", for example oct-products.
  5. Whether to run the camera search for products missing from the list. Default: yes.

Files and state

Keep everything in one working folder:

products-WORK_NAME/
  config.json          videos, draft product list, Vivu project id, query wording per product
  videos.csv           file, episode, duration_s, video_id, transcript file
  upload/              the videos to index (copies of the final exports)
  transcripts/         one .srt or .vtt per video
  results/             one JSON per search, without the result page link
  sheets/              half second contact sheets inside each window
  frames/              full frames the model text was read from
  candidates.csv       every window Vivu returned, with the verdict and the reason
  product_list.csv     the list: one row per product
  description_block.txt  the text the creator pastes into each video's description
  state.json           steps done, files uploaded, searches run with job ids, windows checked

Run every command from the folder that contains products-WORK_NAME/. A rerun reads state.json first: an uploaded video is not uploaded again, a search with a saved result is not run again, and a window with a verdict in candidates.csv is not checked again.

Step 1: Check the Vivu connector and the setup

Goal: confirm every requirement before spending anything.

  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. If the account does not show can_create_projects: true, or a later write call fails with "has not granted vivu.write", ask the user to reconnect Vivu and allow write access, then stop until they have.
  2. Run ffmpeg -version and ffprobe -version, and check that each video has a transcript (or that the speech to text tool runs).
  3. Confirm the Compliance items with the user before anything is uploaded: these are the creator's own videos; anyone else on camera (family, friends, a guest) agreed to be in the published video; and whether any video features children. If one does, upload it only when the creator confirms the guardian consent they hold covers storing it in a private Vivu project (Compliance 3).

Done when vivu_get_account shows can_create_projects: true, both ffmpeg commands print a version, every video has a transcript or a working speech to text tool, and the user has answered the Compliance questions.

Step 2: Measure and price the job

Goal: the videos measured and priced, with the user's approval before anything is uploaded.

  1. Copy the videos into products-WORK_NAME/upload/ with names that keep only letters, digits, "-" and "_" (VIDEONAME below), so Vivu keeps each name as it is. Vivu rewrites spaces and punctuation in file names.
  2. Measure each file and write duration_s into videos.csv:
ffprobe -v error -show_entries format=duration -of csv=p=0 products-WORK_NAME/upload/VIDEONAME.mp4
  1. Call vivu_get_usage and show one table:
This product list Plan allowance Remaining this month
Index minutes sum of duration_s / 60 from vivu_get_usage from vivu_get_usage
Search credits 5 per listed product, plus 5 for the camera search, plus 5 for each rewording (estimate) from vivu_get_usage from vivu_get_usage

Plan facts: 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. For example, three 15 minute videos with ten products are 45 index minutes and 55 credits (estimate): more minutes than Free holds, inside Premium.

  1. If the job does not fit, offer levers in this order: index only the videos the creator is publishing now, then fewer videos per batch across two months, and only then a larger plan. Never drop a video or a product without naming it.

In our test run the 3 videos measured 24.78 minutes. The account used in our test run returns no allowance figures, so the plan table and the user's approval were not exercised in our test run.

Done when every video is in upload/ with a duration_s in videos.csv and the user has approved the minutes and credits.

Step 3: Upload and index

Goal: every video indexed in a private Vivu project.

  1. Call vivu_list_projects and reuse a project named "Products WORK_NAME" if one exists. Otherwise call vivu_create_project with that name and visibility "private". The default visibility is organization, which shows the project to everyone in the user's Vivu organization, and unreleased videos should stay private.
  2. Call vivu_open_upload_page with the project ID immediately before uploading. The link expires in 180 seconds and works once, so never post or store it. Give it to the user to open in their own browser and select every file in upload/, or open it in a browser tool that can attach local files. Claude in Chrome accepts at most 10 MB per upload call, and an exported video is usually larger, so most creators will open the link in their own browser or add the files in the Vivu web app. Never split or recompress a video to fit.
  3. Poll vivu_list_videos about every 30 seconds until every video shows ready. Match each listed file_name to videos.csv and record the video_id; when a name does not match, match by duration_ms against duration_s.

In our test run all 3 videos were ready 14.6 minutes after the upload started; the shorter videos waited in the queue while the longest one indexed. The files went through the upload page with an automated browser, so opening the link in the user's own browser was not exercised in our test run.

Done when every row of videos.csv has a video_id and every video shows ready.

Goal: saved candidate windows for every listed product, plus candidate windows for items shown to the camera.

The chain: one speech search per listed product finds where the creator introduces it (said), Step 5 checks those windows against the transcript, the camera search flips from what was said to what was shown and catches items the list forgot, and Step 7 reads the name and model off the box in frames from those windows. fast is not used: it returns whole files with an empty reason, and each video is one file you already know.

Field Query Mode maximum_results
intro_PRODUCT (one per listed product) the creator talks about PRODUCT_DESCRIPTION: picks it up or shows it and says what it is or what it is for precise 5
unlisted_item (one for the whole project) the creator shows an item to the camera: holds a product, its box or an accessory up toward the lens, or lifts it out of its box under an overhead camera, so the item fills a large part of the picture precise 30

PRODUCT_DESCRIPTION is the creator's name for the product plus what it is in plain words ("a drain soap box, a soap dish that lets water drain away"). When two products in the same batch are alike (a phone stand and a laptop stand, measuring cups and a measuring chart), add what tells them apart and name the other one as not counting ("a small folding stand that holds a phone or a tablet upright on a desk; a laptop stand does not count"). maximum_results 5 leaves room for the few stretches where a product comes up again; for the camera search, 30 covers about ten products in each of three videos. Both values are also the recall ceiling, so raise them for longer videos (the limit is 100).

Run vivu_search_videos (project_id, query, mode "precise", maximum_results) for each. It returns a job ID; call vivu_get_search_results until complete is true. Each status call can wait up to 45 seconds, so a pending search is not a stalled one. Save each result to results/FIELD.json without the result page link. Show the result page link only in the live reply: it expires after four hours, so it never goes into the list or the description.

Done when every listed product and the camera search have a saved result file and their job ids are in state.json.

Step 5: Check the speech windows

Goal: each speech window kept or rejected against the transcript, and a rewording for any product whose windows are wrong.

  1. Read the transcript lines between start_ms and end_ms. Kept: the creator talks about that product. Rejected: the window is about a different product, even one that looks alike. Count rejected windows as false positives and write every window, kept or rejected, into candidates.csv with the reason.
  2. Copy one line where the creator introduces the product into intro_line, word for word from the transcript. The reason text is a paraphrase and has described products that were not in the window, so it never fills a cell.
  3. When a product has no kept window, reword its query once as in Step 4 (say what tells it apart from the look-alike) and run it again. Tell the user which wording changed and why.
  4. A second signal when the transcript is missing or unclear: vivu_get_video_summary with include_segments, start_ms and end_ms around the window. Its section boundaries are rough, so never take a time from it (not exercised in our test run).
Worked example from our test run

The test corpus was 3 public creator videos (24.78 minutes in total): a haul of unbranded household items held up to the camera with listing cards edited in, a talking head unboxing of a branded wireless charger, and a hands-only overhead unboxing of a branded charging dock. Before searching we wrote down every product, when it first appears and what its box says, then gave the searches a draft list that left out the microwave splatter cover and the dock's power adapter on purpose. With the final wordings the speech searches found an intro window for each of the 10 listed products: 13 windows, 0 false. The first wordings had 2 false windows: the phone stand query also returned the laptop stand from the same haul, and the measuring cups query returned only a window about other items, with a reason describing measuring cups that were not there. Each of those queries now uses the wording we settled on after 1 rewording on the same corpus, naming the look-alike as not counting. One product was never named aloud ("the next thing I got is this"), and its search still found the window; the name came from the listing card on screen.

Done when every speech window has a verdict in candidates.csv and every listed product has a kept window with an intro_line, or is marked "not found" after one rewording.

Step 6: Check the camera windows and find what the list missed

Goal: each camera window kept or rejected from frames, matched to a listed product or flagged as a new item.

  1. For each window, make a strip of six frames across it:
ffmpeg -v error -y -ss START -t DURATION -i products-WORK_NAME/upload/VIDEONAME.mp4 -vf "fps=6/DURATION,scale=320:-1,tile=6x1" -frames:v 1 products-WORK_NAME/sheets/VIDEONAME_START_strip.png

START is start_ms / 1000 and DURATION is (end_ms - start_ms) / 1000, both in seconds. For a window longer than about 60 seconds, make a half second sheet of the whole window instead, because a short appearance falls between six tiles:

ffmpeg -v error -y -ss START -t 32 -i products-WORK_NAME/upload/VIDEONAME.mp4 -vf "fps=2,scale=256:-1,tile=8x8" -frames:v 1 products-WORK_NAME/sheets/VIDEONAME_START_sheet.png

One sheet covers 32 seconds; tile k is at START plus k/2 seconds. Repeat from START plus 32 until the window is covered. 2. Kept: the frames show an item, its box or an accessory held or lifted toward the camera. Rejected: shipping bags and mailers, or an item that is small in a talking head shot. Count rejected windows as false positives. 3. Match each kept window to a listed product by looking at the frames, not by the reason (the reason once called a charger base a power adapter). Every item that matches nothing on the list goes to the user as a NEW row candidate with its frame: a product the list forgot, an accessory from the box, or a prop such as the phone used to demo a charger. The creator decides which ones belong in the description. 4. An empty camera search, or no window for an item, does not prove the item is not in the video. Tell the user that the list still depends on their draft.

In our test run the camera search returned 23 windows: 20 real and 3 false (shipping mailers and a small box beside the creator's face). It brought back the microwave splatter cover we had left off the list. It missed the power adapter we had also left off: the adapter was only on the last tiles of a wide window whose reason described the box, which is why long windows get a full half second sheet. It also turned up a thank-you card from a box and a second charger box from the same brand, which the creator would sort out by hand.

Done when every camera window has a verdict in candidates.csv and every NEW item has been shown to the user with its frame.

Step 7: Read the model text and set first seen

Goal: for each product, the brand and model text read from a full frame, and the time it first appears.

  1. Pick the kept window (speech or camera) where the box or the product label faces the camera, and extract a full frame from the middle of that stretch:
ffmpeg -v error -y -ss SECONDS -i products-WORK_NAME/upload/VIDEONAME.mp4 -frames:v 1 -q:v 3 products-WORK_NAME/frames/VIDEONAME_SECONDS.png
  1. Copy only the brand and model words printed on the box or the product, exactly as written. Leave the cell blank when nothing readable is printed, and say why ("label too small to read", "plain bag, no brand"). A name on a listing card the editor added is on-screen text, not packaging; use it for the product name, not as a model. Text in the background (a fridge maker's logo behind a fridge magnet) is not the product's. Never complete a word from the reason text, the captions or memory: captions misspell brands, and a guessed model sends viewers to the wrong product.
  2. first_seen is the earliest start_ms of any kept window for that product, from either search, written as MM:SS. It can still be late: the creator may show the box in the opening lines before any window starts. Make a half second sheet of the 32 seconds before first_seen (Step 6 command, START = first_seen minus 32) and move first_seen back if the product is already being shown; if you cannot tell, mark first_seen UNCERTAIN.

In our test run the model text we read from frames matched what we had written down before searching: the ESR and Nomad boxes and the plain laptop stand box were read as printed (glare hid part of a word on the Nomad box), the power adapters' labels were too small to read and stayed blank, and the haul items' bags carried no brand at all. For one product the earliest window started after the creator had already held its box up in the intro, so the chapter time would have been late; the sheet before first_seen was not exercised in our test run. For the measuring cups the camera window started earlier than the speech window and set first_seen.

Done when every product row has a frame_path, a model_text_from_frame value or a reason it is blank, and a first_seen.

Step 8: Write the list and the description block

Goal: product_list.csv and description_block.txt that the creator has checked.

  1. Show the user one sample row and the field mapping, and wait for a yes before writing the rest:
product,episode,source_file,first_seen_mmss,model_text_from_frame,intro_line_from_transcript,frame_path,chapter_line,buy_link,found_by,status
3-in-1 wireless charger,EP02,EP02_KBAVdn6zuWM.mp4,00:49,ESR HaloLock 3-IN-1 WIRELESS CHARGER with CryoBoost,"i'll be looking at the new esr31 headlock wireless charger with cryoboost",frames/EP02_KBAVdn6zuWM_52.png,00:49 ESR HaloLock 3-in-1 Wireless Charger with CryoBoost,,speech search + camera search,UNCERTAIN first_seen
Field Source If unavailable
product the creator's draft list, or the listing card or box for a NEW item none
episode, source_file videos.csv none
first_seen_mmss earliest kept window, checked on the sheet (Step 7) UNCERTAIN
model_text_from_frame full frame (Step 7) blank with the reason
intro_line_from_transcript transcript, word for word (Step 5) NOT VERIFIED without a transcript
frame_path the frame the model text was read from blank
chapter_line "MM:SS Product name" from first_seen and the model text or product name none
buy_link left empty for the creator stays empty
found_by speech search, camera search, or both none
status checked, NEW (confirm with creator), UNCERTAIN, or not found none
  1. Write product_list.csv with one row per product, including NEW items the creator kept and listed products marked "not found".
  2. Write description_block.txt: for each video, a "Products in this video" list with LINK placeholders and a chapters list. YouTube chapters start at 00:00, need at least three entries and each must run at least 10 seconds, so merge a product that appears in the first seconds into the 00:00 line and leave chapters out for a video with too few products. Add one line reminding the creator to add their own affiliate or gifted product disclosure; the skill does not write it.
  3. Add a short summary for the user: products found, NEW items, rows marked UNCERTAIN or not found, and per search how many windows Vivu returned and how many were rejected as false positives.
  4. The creator fills in buy_link and pastes the block into each video's description themselves. If they ask Claude to post it, put it in a shared doc or edit the video description through another connector, name the destination, show the full text, and wait for explicit approval.

In our test run the list has a row for each listed product plus the recovered splatter cover marked NEW, and the description block left chapters out for the video with a single product, since YouTube needs at least three. The user's approval of the sample row was not exercised in our test run, and nothing was posted.

Done when product_list.csv has a row for every listed product and every kept NEW item, description_block.txt has a section per video, and the user has approved the sample row.

Compliance

  1. Use only the creator's own videos, from their own files. Confirm this in Step 1; the skill does not import platform links or other channels' videos.
  2. Family, friends or guests on camera agreed to be in the published video; this skill only reads it for a local list. It reads speech and printed text only and does not identify anyone by face, or any brand by its logo.
  3. If a video features children, upload it only when the creator confirms the guardian consent they hold covers storing it in a private Vivu project; otherwise build that video's rows from the transcript alone, marked NOT VERIFIED for model text.
  4. Affiliate links, gifted products and sponsorships are disclosed by the creator under their platform's rules. The skill leaves the disclosure line for the creator to write.
  5. The videos stay in the user's Vivu project until the user deletes them. Create the project as private. Delete a project or video only when the user asks, and confirm first.
  6. Posting the description or editing the video acts as the creator; the skill leaves that to them or asks first (Step 8).

Known failure modes

Symptom Cause Fix
(observed) the phone stand search also returns the laptop stand from the same haul two look-alike products in one batch reword once, naming what tells them apart and the look-alike as not counting (Step 4)
(observed) the reason says "The creator unboxes and shows a set of 4-piece measuring cups, explaining their measurements and how they will make her baking easier." but the window is about other items the reason text paraphrases and can describe what the query asked for judge every speech window from the transcript (Step 5)
(observed) a product left off the list shows up only on the last tiles of a long camera window wide windows cover several items and the reason names one make a half second sheet of any window longer than about a minute (Step 6)
(observed) the reason says "The creator takes the power adapter out of its packaging and holds it up close to the camera lens." while the frames show the charger itself the reason misnames the item match camera windows to products from frames only
(observed) captions write the brand as "esr31 headlock wireless charger" auto captions mishear brand names read the model from the box frame; quote captions as they are only in intro_line
(observed) the earliest window for a product starts after its box was already shown in the intro windows start where the search places the introduction, not at the first appearance check the stretch before first_seen on a half second sheet, or mark it UNCERTAIN
(observed) shipping mailers come back from the camera search a held up bag looks like a held up product reject them in Step 6
a small label or a reflective box cannot be read low resolution frames and glare leave the cell blank with the reason; ask the creator for the model
an item never held up and never named is missing from the list both searches need a mention or a clear showing an empty result does not prove the item is absent; ask the creator to check the list
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
a file is rejected by the browser upload tool Claude in Chrome accepts at most 10 MB per upload call the user opens the upload link in their own browser or adds the file in the Vivu web app
"has not granted vivu.write" Vivu connected read only the user reconnects Vivu with write access

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.