Przejdź do treści
Biblioteka skilli
Marketing i treści · Budowanie i kod

aicut-explainer

/aicut-explainer

Tworzy pionowe wideo wyjaśniające z narracją i animowanymi liczbami przez CLI aicut: porównania, rozbicia kosztów, sceny i napisy zsynchronizowane z głosem.

Repozytorium
skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
04.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
3
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 04.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Tworzy pionowe wideo wyjaśniające z narracją i animowanymi liczbami przez CLI aicut: porównania, rozbicia kosztów, sceny i napisy zsynchronizowane z głosem.

Oryginalny opis (EN)

Make a narrated explainer video with the aicut CLI (`aicut explainer create`): animated numbers, breakdown and compare cards, callouts, stage scenes with a camera and a HUD, one to six voices and word-synced captions, 20 to 180 seconds, vertical, in 29 languages. Use for a cost comparison, a buy-or-lease decision, a budget simulation, a short story or any explainer told with numbers and motion graphics.

Jak działa

  1. Setup
  2. Spending tokens: the rule
  3. The flow
  4. References
Sekcje z nagłówków SKILL.md, w oryginale · 78 linii, 3 447 słów
Podgląd SKILL.md
---
name: aicut-explainer
description: "Make a narrated explainer video with the aicut CLI (`aicut explainer create`): animated numbers, breakdown and compare cards, callouts, stage scenes with a camera and a HUD, one to six voices and word-synced captions, 20 to 180 seconds, vertical, in 29 languages. Use for a cost comparison, a buy-or-lease decision, a budget simulation, a short story or any explainer told with numbers and motion graphics."
---

# Make an explainer video

Make a narrated motion-graphics explainer video with the aicut CLI: write the script as JSON, make the pictures, price them with the video, ask once, and generate it in one command.

## Setup

Check the CLI first: `aicut --version`. If the command is missing, install it with `npm i -g aicut-cli` (Node 20 or newer), then sign in with `aicut login`: it opens the browser and the user approves. `aicut account` shows who is signed in and the token balance. More in `references/setup.md`.

Never read the CLI's credentials file and never run `aicut token`: the CLI looks after its own session.

## Spending tokens: the rule

Creating video, images and audio costs tokens from the user's aicut balance. Every command that spends can price itself first. The flow, every time:

1. Run the command with `--estimate`. It prints the price and charges nothing.
2. Tell the user the price and what it buys, in the same message as your ask, and wait for their explicit go for THAT purchase. A bare "yes" counts only as the direct answer to your priced ask, with nothing else raised or outstanding; if it is ambiguous, ask which purchase they mean.
3. Only after the go, run the same command with `--max-tokens <quote> --yes`, where `<quote>` is the price you told them.

Without a terminal (you, a script, CI) `--max-tokens` on its own is already a go: the command spends as soon as the quote is within the number. So never put `--max-tokens` on a command before the user has said go. `--yes` only skips the y/N question, and only together with `--max-tokens`.

Two steps need more than a go:

- `aicut story fire` generates every scene video and cannot be undone or refunded. It needs a go that NAMES firing ("fire it"), given in reply to an ask about firing alone, and then `--confirm-fire --max-tokens <quote> --yes`. A bare "yes" never fires.
- `aicut post publish` puts a post live under the user's name. It needs a go that NAMES publishing, and then `--confirm-publish`.

A go covers one purchase at the price you quoted. If anything changes (the model, the length, the text, a setting) estimate again and ask again. A retry after a failure is a new purchase: new estimate, new go. But a paid command your shell cut off may already be charged, so never run it again: find the job (`aicut list videos|images|audio`, or `aicut story get <id>`) and follow it with `aicut wait <id>`. Never switch to a cheaper model or lower settings to save tokens without saying so. Pictures of real people only with their permission, never public figures. When a price is more than the balance the command refuses and prints a top-up link: give it to the user and stop.

## The flow

EXPLAINER VIDEO: a narrated 9:16 motion-graphics video made from a script you write as JSON: animated numbers, breakdown and compare cards, callouts, stage scenes with a camera and a HUD, one to six voices and word-synced captions, 20 to 180 seconds, in any of 29 languages.

This text is a guide, not the user's go. It authorizes no spend: the paid call below is priced first and made only after the user's go for that purchase.

0. Run `aicut account` to see the balance. If it is 0, the account has no tokens: tell the user so, give them https://www.aicut.pro/billing, and stop until they have added some. Price nothing first. (A price above the balance is refused later with the same link: give it to the user and stop.)
1. WHAT TO MAKE: ask the user for the topic, the facts and numbers they want shown, the language and a rough length. You never invent a figure: use the numbers the user gave you or ones you can source, and say which. Ask nothing else before the script; pick the format and the look yourself and show them in the script (the voices are chosen by preview, below).
2. PICK THE FORMAT. DATA (the flat infographic): a two-party cost comparison or a three-way decision, built from `title`, `counter`, `breakdown`, `compare`, `callout` and `cta` scenes. STAGE (the simulation or the story): a picture of a place with a moving camera, items, tags, a HUD of running numbers and speaker-tagged dialogue, built from `stage` and `title_card` scenes.
3. THE HOOK AND THE ARC, which every format here shares. Cold open: a question or a situation in at most 8 words ("Shop A or Shop B, who earns more?"). Build: numbers accumulate, each scene adds one (a running total, an interim score). Turn: a reveal that changes the answer ("and now comes the catch"). Payoff: ONE summary number or a kicker line. Close: a comment prompt (a `cta` scene, or a closing line asking which they would pick) or "part 2 follows" for a story. Pace: a new scene every 5 to 6 seconds (10 to 12 scene changes a minute), each carrying one on-screen number or label; effects: `sfx` whoosh on a scene change, pop on a reveal, cash on a money beat, ding on the turn; narration lines of 5 to 14 words; one voice for a data video, up to six for a story. DATA: a two-party comparison runs about 135 s with 11 or more scenes (match-up title with two avatars, price then and now with a percent badge, a cost breakdown, per-unit and monthly bars, the catch as an hourly figure, a verdict callout); a three-way decision runs about 115 s (one breakdown per option with a running total, the result as a four-column `bars` compare with the `winner`, three recommendation cards, then a `cta`). STAGE: a simulation runs about 175 s (a HUD of days, stock and budget, one stage per step, the budget falling); a story about 80 s (night, a place, several speakers, a car stops, a power cut, "part 2 follows").
4. THE SCRIPT, IN BRIEF. Save the script as a JSON file and pass it with `--script @script.json`. It is one JSON object; unknown keys are refused, and a refusal names the field.
{ "v": 1, "lang": "German", "theme": { "mode": "dark" | "light", "accent": "#ff9f1c", "accent2": "#hex" (optional) }, "captions": "pill" | "off", "voices": { "narrator": "<voice id>", "friend": "<voice id>" }, "scenes": [ ... ] }
`lang` is the language NAME (English, German, French, Spanish, Italian, Portuguese, Dutch, Polish, Czech, Slovak, Croatian, Bulgarian, Romanian, Greek, Turkish, Russian, Ukrainian, Swedish, Norwegian, Danish, Finnish, Indonesian, Malay, Thai, Hindi, Arabic, Chinese, Japanese, Korean) and the text must be written in it. `voices` names are lowercase letters, digits and underscore (at most 24 characters), `narrator` is required, at most six voices. A `captions: "pill"` video burns word-synced captions in; "off" shows none.
EVERY SCENE has `kind`, `lines` and optionally `sfx` (one of whoosh, pop, cash, ding). A line is `{ "say": "...", "speaker": "<a voices name>" (omit for the narrator), "pause": 0 to 2 seconds (default 0.25) }`. The whole script has 3 to 80 lines, a `say` is at most 400 characters and must hold a letter or a digit and no < or >.
- `title`: `eyebrow`, `text`, `sub`, `avatars` (up to two of `{ "emoji" | "url", "label" }`).
- `counter`: `value` (a typed number), `label`, `atLine` (the line it starts ticking on).
- `breakdown`: `title`, `items` (1 to 12 of `{ "icon": emoji, "label", "amount": a typed number }`), `total` (`{ "label", "value": a typed number }`).
- `compare`: `title`, `style` ("cards" or "bars"), `columns` (2 to 4 of `{ "label", "value": a typed number, "icon", "note" }`), `winner` (a column index).
- `callout`: `text`, `avatar` (`{ "emoji" | "url", "label" }`), `bubble` (a speech line), `badge` (a short tag such as "+67%").
- `cta`: `prompt` and `options` (1 to 4).
- `stage`: `background` (a picture url), `camera`, `items`, `tags`, `hud` (up to 12 of each, `value` a typed number or a short text; see the stage rules), plus `lines`.
- `title_card`: `text` (leave it out for a black screen).
TEXT IS SHORT: eyebrow, sub, title, counter and compare labels and a title card are at most 80 characters, a callout, its bubble and a cta prompt 120, an item label, a column label or note and a tag 40, a badge and a HUD text 24, each cta option 40. A NUMBER on screen is typed: `{ "value": 38, "format": "currency" | "number" | "percent", "currency": "EUR", "decimals": 0 to 4 }`; `currency` is an ISO 4217 code and belongs to the `currency` format only.
5. LENGTH: the video runs 20 to 180 seconds, estimated from the words you write (about 2.2 seconds a line, plus every authored pause); a script outside that is refused before anything is charged, and if the spoken result comes out more than a quarter longer than the estimate (long abbreviations, odd names) the run fails and is refunded in full. The text is also capped per language: 3600 characters of speech in most languages, 3000 in Hindi, 2550 in Arabic, 2400 in Thai, 1800 in Korean, 1200 in Japanese and 1050 in Chinese. In practice the length binds first. Pictures: at most 10 distinct urls in one script.
6. NUMBER HYGIENE. The digit appears on screen ONCE, in the typed number or the label, and the narration says it in WORDS: write 'thirty-eight euros' in `say` (in the script's language) and `38` in the number, never 38 in `say` (it would be read twice and mispronounced in some languages). A percent value is in percent units: 15 shows 15%, 0.15 shows 0.15%. A breakdown item and a compare column carry no line index: they enter one after another across the scene's lines, in the order you list them, so write the lines in the same order as the items and columns, one item per line where you can. A counter ticks up on its `atLine` (the scene's first line when it is left out). Put a different number in every scene.
7. LANGUAGE. Write every `say` and every on-screen string in the script's `lang`, with that language's own number words. Arabic is laid out right to left by itself: write it normally, never reverse or pad it. Chinese, Japanese and Korean render in ONE bold weight whatever the scene asks for, so do not lean on light or medium text there, and their character caps are much tighter (above): write shorter lines. A language outside the list above is not available; say so rather than approximating it.
8. STAGE RULES (stage scenes only). Coordinates `x` and `y` run 0 to 1 across the picture. A CAMERA keyframe `{x, y, zoom, atLine}` is the pose the camera HAS on the first frame of its `atLine`: the move into it happens across the line BEFORE, so to push in on line 2, put the keyframe on line 2. A keyframe on line 0 is the opening shot; before the first and after the last the camera holds; `zoom` 1 shows the whole stage whatever `x` and `y` are, up to 3. ITEMS (`{url or emoji, x, y, scale, atLine, enter}`) are masked picture cards or emoji that enter on their line; `scale` 1 is half the frame wide, so use 0.2 to 0.5. TAGS (`{text, x, y, atLine}`) are labels with a pointer; a later tag placed near an earlier one (within about 0.3 across and 0.08 down) REPLACES it, otherwise a tag stays until the scene ends. Keep items and tags in the middle of the stage: the top 150 to 330 pixels of the frame belong to the HUD and the bottom to the captions, so keep y between 0.2 and 0.75. The HUD (`{id, label, value, side, atLine}`, `side` left or right) PERSISTS across consecutive stage scenes with its last value, a later entry with the same `id` updates it (a number ticks to the new value, text swaps), and ANY scene that is not a stage (a `title_card`, a data scene) CLEARS it, so declare the entries again after one. SPEAKERS: a line with a `speaker` other than the narrator gets that speaker's name tag, in a stage scene, and ONLY when the script has `captions: "pill"`, so a dialogue script must use pill captions. The narrator is never tagged.
9. VOICES: every id in `voices` comes from `aicut voices --provider elevenlabs --usable-for audio --limit 100 --json`; never invent one. Only ElevenLabs library voices work here: an OpenAI voice, or a voice cloned in the user's own workspace, is refused because it gives the video no word timing. Use a different voice for each speaker. Choose the voice by PREVIEW, not by spend: run `aicut voices --provider elevenlabs --usable-for audio --limit 100 --json`, propose 2 or 3 that fit what the user described, each with its `preview_url` link beside its name (a link the user can play; OpenAI voices have none, so describe those), and let them pick BEFORE any paid call. Never generate the same line in several voices to compare them, unless the user asks for that and has been told the total price of it. A data video needs only the narrator.
10. PLAN THE PICTURES. Emoji cover a data video, so it needs none. A stage needs a `background` picture (portrait, 9:16, no text in it), and avatars and stage items are pictures too (square, one subject on a plain background; they are shown as circles or cards, so there are no cut-outs). Plan every picture now (what each one shows); you make them with `aicut generate image` only after the user's go (below), before the script is final, and put the url each one prints into the script exactly as printed. Only aicut-hosted pictures work: a url from `aicut generate image` or `aicut upload` (a url from the web is refused). A picture on the user's own machine: `aicut upload <path>` prints its url. Pictures of real people only with their permission, never public figures; draw fictional characters. Find an image model with `aicut models list --type image`: use the one the user named, or the one marked `recommended`.
11. SHOW, PRICE, ASK. Write the whole script and show it to the user as plain text (the scenes and the lines, not the JSON) with the pictures described; change it until they like it, because iterating costs nothing. Then price BOTH parts and ask ONCE. The pictures: `aicut generate image --model <id>` with the prompt and `--estimate` for each distinct picture. The video: `aicut explainer create --script @script.json --estimate`. The video price depends only on the lines (their words, speakers and pauses), never on the scene kinds or the pictures, and the real picture urls do not exist yet, so price a PICTURE-FREE COPY of the script, saved as a second file such as `price.json` (`aicut explainer create --script @price.json --estimate`): the same `voices` and EVERY line in the same order with its own `speaker` and `pause`, put in `callout` scenes with a short `text` and no avatar (at most 80 lines in total). It prints the length in seconds and the price. Say in ONE message what the pictures cost, what the video costs, the total, and the length in seconds, ask, and wait for the user's go for exactly that set. Anything the user changes after the quote (a line, a picture, a voice) ends that go: quote again.
12. After their go: run each picture with its own `--max-tokens <that picture's price> --yes` and no `--wait` (each prints its job id at once), then `aicut wait <id>` for each id until it prints the url. Show the pictures to the user. If one is wrong, redrawing it is its own priced ask. Then put the urls into the script, price the REAL script with `aicut explainer create --script @script.json --estimate`, and check that it equals the quote you gave; if it differs, tell the user the new price and ask again. If it matches, run the same command again with `--max-tokens <the price you quoted> --yes --wait`. Never put `--max-tokens` on a command before that go: without a terminal it is itself the go. One command makes the finished video: there is no render step. `--wait` blocks until the job is done (up to 10 minutes) and prints the media url; add `-o <path>` to save the file too. If your shell tool cuts a command off sooner than that, leave `--wait` off from the start: the command prints the job id, then run `aicut wait <id> --timeout 90` again until it prints the url (exit code 3 means still running, not failed). If a run that had `--max-tokens` is cut off, NEVER run it again: the job exists and is charged, so find it with `aicut list videos|images|audio` and follow it with `aicut wait <id>`.
13. Hand the user ONE thing: the finished video, with one line about its length. Do not read the script back at them. It cannot be edited or re-rendered afterwards: a change is a new video and a new purchase.

IF IT FAILS: a refused script (nothing charged) names the field; fix that field and price again. A video that fails after it started is refunded in full and has no retry, so a new one is a new purchase with its own quote and go. If the job fails, read its `error:` line and tell the user what went wrong. Any resubmit is a new purchase with its own price and go, and never the identical request twice: change the model or the prompt, or ask.

WORKED EXAMPLES: aicut keeps six reference scripts in packages/remotion-contract/src/inputProps/explainer-fixtures/ in the aicut-pro/backend repo (in the aicut-pro/aicut-webapp repo, lib/shared/remotion-contract/inputProps/explainer-fixtures/). They are summarised here, so you do not need to open them; their voice ids are placeholders and their numbers are made up, never reuse them as facts. The shortest ones are under the 20 second minimum, so treat them as shape references, not as scripts to send.
- two-shop-costs.json (DATA, German, dark, accent orange, one narrator, about 135 s): a hair salon against another. It opens with a `title` with two emoji avatars and a match-up question, a `counter` of today's price, a `callout` carrying the "+67%" badge, a `breakdown` of material costs, a `counter` of what stays per cut, a second `breakdown` for the rival, `compare` bars for the interim score, fixed costs and time per cut, a `callout` with a speech bubble, a three-column `compare` of monthly profit, the catch as a `title` and an hourly-wage `compare`, and a verdict `callout`. It ends on a comment prompt (send a `cta` there; the fixture uses a `title_card`).
- three-way-decision.json (DATA, German, light, accent teal, about 115 s): the same car three ways. A `title`, then one `breakdown` per option with running totals (each followed by a `callout` for its trap), a percent `counter` for the depreciation, a four-column `bars` `compare` with the `winner`, an exception `callout`, a `compare` of three recommendation cards and a closing `cta` with three options.
- budget-simulation.json (STAGE, German, dark, accent purple, one narrator, about 150 s): a bunker budget. A `title`, then seven `stage` scenes over one cross-section picture, each with camera keyframes that push in on the step being talked about, emoji items, tags such as the formula pop-up, and a three-entry HUD (days and stock on the left, budget on the right) that keeps its values from one stage to the next and is declared again after a `title_card`; it ends on a blackout `title_card`.
- night-shift-story.json (STAGE, German, dark, accent red, four voices: narrator, coworker, radio, driver, about 65 s): a night at a petrol station. Dialogue lines carry a `speaker`; `captions` is `"pill"` so each non-narrator line shows its name tag; camera in and out on the beats, a clock tag, four camera-feed item cards in one scene, a "03:31" `title_card` after the power cut and "part 2 follows" as the last `title_card`.
- short-ja.json and short-ar.json (DATA, about 10 and 20 s): the Japanese (yen amounts, one bold weight) and Arabic (right to left, a riyal counter) scripts of three scenes each: they show the language settings, and a real script needs more lines to reach 20 seconds.

A SHAPE EXAMPLE (English, two scenes, narrator only; the real minimum is 3 lines and 20 seconds, which needs about 45 words, so write more):
{"v":1,"lang":"English","theme":{"mode":"dark","accent":"#ff9f1c"},"captions":"pill","voices":{"narrator":"<voice id>"},"scenes":[{"kind":"title","text":"Shop A or Shop B?","sub":"Who earns more","avatars":[{"emoji":"💈","label":"A"},{"emoji":"✂️","label":"B"}],"sfx":"whoosh","lines":[{"say":"Shop A or shop B, who earns more?"},{"say":"Both cut hair, but only one keeps real money."}]},{"kind":"counter","value":{"value":38,"format":"currency","currency":"USD"},"label":"A haircut at shop A","sfx":"pop","lines":[{"say":"A cut at shop A now costs thirty-eight dollars."}]}]}

## References

- `references/setup.md`: install, sign in, output and exit codes
- `references/spend.md`: how the spend guard decides
Pliki w paczce (3)
  • SKILL.md 20 KB
  • references/setup.md 1 KB
  • references/spend.md 2 KB

Wersje

W bazie nie ma innych skilli o nazwie aicut-explainer.

Migawka bazy z 13.11.2026 · wersja paczki c17a155d933e (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100aicut-image-story
    Tworzy narracyjne wideo z obrazów AI za pomocą aicut CLI: skrypt dzieli się na sceny, każda z obrazem AI, lektorem i napisami, dla filmów o faktach, historii, grozie i wyjaśniających.
  • 100aicut-explainer-studio
    Tworzy pionowe, beztwarzowe wideo typu co by było, gdyby w stylu popularnych rolek, rysowane kodem i opowiedziane lektorem, trwające od 15 sekund do 5 minut.
  • 95v1-explainer-video
    Tworzy animowane wideo wyjaśniające z narracją, np. objaśniające pull request albo trudną koncepcję.
  • 96explainer-videos
    Tworzy zaplanowane wideo wyjaśniające z narracją i wizualizacją rozumowania, także do lekcji i prezentacji.
  • 100explainer
    Tworzy filmy wyjaśniające z narracją i wizualizacjami generowanymi przez AI, także jako filmy instruktażowe.
  • 100aria
    Tworzy gotowe filmy z głosem z kodu: pisze scenariusz, nagrywa narrację z emocjami, dopasowuje napisy i renderuje sceny React w pliku MP4.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.