remake-viral-video
Skill2 starsChanged 20 days agoMITView on GitHub
Have Kabo produce a finished MP4: remake a viral talking-head or voice-over video (up to 10 min) with the creator, make one from an approved script, build one from steps (new words on the creator's own video, the creator in a reference's shot, B-roll, or nobody on camera: animation, narration), or change a delivered one. Use only when the user wants the video itself made or changed; not for writing or adapting a script, breaking down a video, or reviewing an account.
In this repository22 other files it gives its agents.
- AGENTS.mdAGENTS.md
- analyze-content-videoSkill
- analyze-creator-competitorsSkill
- analyze-tiktok-competitorsSkill
- create-script-and-packagingSkill
- develop-content-ideasSkill
- diagnose-reach-dropSkill
- optimize-creator-brandSkill
- pick-daily-viral-videosSkill
- plan-content-calendarSkill
- plan-platform-monetizationSkill
- price-creator-brand-dealsSkill
- recommend-publish-timingSkill
- research-instagram-trendsSkill
- research-tiktok-trendsSkill
- research-youtube-trendsSkill
- review-creator-account-deepSkill
- review-creator-accountSkill
- review-new-postsSkill
- review-thumbnailSkill
- start-with-kaboSkill
- verify-platform-ruleSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
24 rules. About 0 are common, 10 are distinctive, and 14 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈10
Distinctive · estimate
This author's own choices. Worth a look.
14
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 23
Use this Skill only to make or change the video itself.
- Distinctive: line 28
Keep everything the user did not ask to change.
- Distinctive: line 29
Keep real pixels where you can.
- Very specific: line 30
Use the material already here first -- the reference, the creator's footage and photos, a delivered video's master.mp4, takes, B-roll and …
- Very specific: line 33
Ask only what only the user can decide or knows (a fact, a real trade-off, money beyond the plan).
- Very specific: line 61
Before the first project step or edit, read references/atoms.md (steps and costs) or references/edits.md, say in 2-3 lines what you will …
- Very specific: line 93
Only the talking-footage model can be chosen, from the options get_remake_video returns at the script gate (step 6).
- Very specific: line 113
Saving a tool result: When a step says to save a result, write the complete get_remake_video or render_remake_video result (the host's …
- Very specific: line 118
No reference, only a script?: If the user wants a video of the creator saying words they already approved, follow …
- Distinctive: line 157
If the user states a length over 10 minutes, say the limit is 10 minutes and ask for a shorter one.
- Distinctive: line 172
Before the first paid call, tell the user in a sentence or two what will happen: the method above and that it takes 30 min to 3 hours.
- Very specific: line 194
Read references/tool-errors.md and follow it.
- Very specific: line 229
Read references/script-gate.md whole, then the references it names for the judgement in front of you.
- Very specific: line 233
Keep the reference's lines word for word and in order.
- Distinctive: line 236
Keep the reference's on-screen title and numbered list.
- Distinctive: line 238
Write the opening record with 2-3 candidates, and choose one yourself.
- Distinctive: line 240
Write the plate and anchor prompts without describing the framing, holding the creator's hair and outfit exactly as in the identity …
- Very specific: line 243
Write the four documents as script/script.json, script/opening_review.json, script/decisions.json and script/route_b_jobs.json.
- Distinctive: line 280
Never choose for the user and never ask about the model before the script is written.
- Very specific: line 292
The runner checks the documents first, after render returns: If a later get_remake_video shows waiting_script again with gate_message, …
- Very specific: line 319
Read references/final-review.md and relay fetch's review_message and notes_for_user as it says.
- Distinctive: line 322
Do not claim improved views, retention or likeness.
- Very specific: line 327
Every final status (out_of_scope, failed, timed_out) carries failure and usually failure_reason.
- Very specific: line 331
When the user's next step is outside this Skill, name the Skill that fits -- for example create-script-and-packaging for a script only, or …
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Remake Viral Video
Kabo's servers make every picture and sound, through three paths: a whole remake (steps 1-8:
the runner analyses, voices, films, grades, captions and delivers; you write the script), an edit
of a delivered video (edit_remake_video), or single steps in a project or on a delivered job
(start_video_project, make_video_step, finish_video_project). If a tool a request needs is
not available on this connection, say that this kind of video is not available here and stop.
A remake takes 30 min to 3 hours, mostly waiting on the runner. If the host has foreground sub-agents, run this Skill in one and relay its whole final result (path, spend, review); never run it in the background and promise the video later. Otherwise follow the steps in the main thread.
Choose what to make
Use this Skill only to make or change the video itself. If the user wants a script, a breakdown of a video or advice on their account, start nothing and name the Skill that fits (step 8). Otherwise, before any tool call, write one line: what must stay, what must change, and the table rows that do it. Decide by that, not by the request's wording ("remake" included):
- Keep everything the user did not ask to change.
- Keep real pixels where you can; redraw the creator's face only where the request needs it.
- Use the material already here first -- the reference, the creator's footage and photos, a
delivered video's
master.mp4, takes, B-roll and first frames, earlier results. Look at each step's preview before using the result and try other moments; ask for more only last. - Ask only what only the user can decide or knows (a fact, a real trade-off, money beyond the
plan). Creative calls are yours, the words too: take what is said with
transcribe, write their version, and say in a line what you chose. - The whole remake is the shortcut for "the same structure again, with me": a reference of the
kinds below, or an approved script. When a narrated reference video IS provided (screen walkthrough, UI tutorial, animated/drawn explainer, map or chart narration), always run the whole remake (
start_remake_video->references/formats/narration.md), neverstart_video_project/make_video_step. It is not the fallback, and a reference plus the creator's footage does not make a request one. The creator's own video is footage to keep, not a reference. What it does not make (the reference's own shot and moves, the creator's own video with new words, B-roll, a product close-up, or faceless videos without a narrated reference to remake) is built from steps, or added as edits after delivery. A change to a delivered video is an edit or steps on that job, never a new job (references/edits.md).
| Keep | Change | Step | Redraws the face |
| the creator's footage | the words, or their language | tts (their voice), then lipsync | mouth only |
| footage and words | the voice's tone | voice_change | no |
| the creator and the words | the background | bg | no |
| a reference shot: camera, moves, props | the person, then the words | replace, then lipsync | yes |
| a movement in any video | who does it | motion (a picture of the creator: a frame of their footage will do) | yes |
| the creator's look | a new still of them (pose, framing, outfit, setting) | first_frame (edits a frame or photo) | yes |
| the creator's look | a new shot of them, silent | refvideo | yes |
| a picture of the creator | they speak a line | talking | yes |
| any video or picture | what is laid over, cut in, joined, arranged or enlarged | overlay, splice, concat, layout, crop, trim, frame | no |
| any video | its speed, length, shake, flash or punch-in zoom | retime, shake, flash, impact_zoom | no |
| a sound | its level, fades, tempo or length | audio_edit | no |
| pictures | held as a clip, maybe a slow push-in | still_video | no |
| any video or picture | burned-in text removed | inpaint_text | no |
| a video or sound | -- (what is said, timed) | transcribe | no |
| -- | a picture without the creator; UI/map/diagram/chart/HUD motion graphic; text; captions; music; sound | still, animate, motion_graphics, text_cards, captions, music, mux | no |
Before the first project step or edit, read references/atoms.md (steps and costs) or references/edits.md, say in 2-3 lines what you will make and the rough cost,
then go ahead. A degraded face check never blocks delivery: say which part looks less
like the creator. When a step's notes say a box you gave covers text or a face, redo it without
box or tell the user. Cancel a job (get_remake_video with "cancel": true) only when the user asks;
spend so far stays charged. Stopping takes a minute or two: keep calling get_remake_video (30 s apart)
until the job or last_step is no longer running; if you stop sooner, tell the user the
cancel was requested and is still stopping, not that it stopped.
What a whole remake covers
- A reference of 10 minutes or less where one person talks to the camera for most of the
video, at any distance, with a fixed or slightly handheld camera. Three talking kinds (the
runner tells them apart; nothing to ask): pure talking head; talking with screens (the video cuts to screen recordings or
screenshots, or shows them floating over the speaker's room); talking with a product (the
speaker shows a physical thing and the video cuts to close-ups of it). Also voice-over
references (nobody on camera; a voice over a screen recording, an animated explainer, scenes or
kinetic type): the creator's cloned voice reads the script and every picture is made anew --
see
references/formats/narration.md. - Refused by the runner before any video is generated (
out_of_scope): references over 10 minutes, walking, vehicle or first-person vlogs where the camera keeps moving, dialogues between several people, and -- for a talking head -- a speaker on camera less than about half the time or mostly other footage. So are creator videos with no clear frontal view of the creator's face, except a voice-over, which needs only the creator's voice. - The creator is framed as the reference frames its speaker, shot by shot; the reference's other shots (cutaways, inserts, other people) are reused from its own footage. The reference's speaker never appears in the result.
- One method: the reference's content and setting are kept and the creator is placed into a rebuilt scene (route B), not into its own shot and moves. Four kinds of line are rewritten in the creator's voice (the opening, the original author's claims about themselves, one closing summary and the call to action); the rest of the reference's lines are kept, or dropped with a reason. The whole face is generated, so likeness is lower than real footage of the creator.
- The final video has no on-screen label, notice or watermark; never say it has one.
- Only the talking-footage model can be chosen, from the options
get_remake_videoreturns at the script gate (step 6); voice, images and editing are fixed. If the user asks for another model (e.g. Veo, HeyGen, ElevenLabs), say so in a line and go on.
Set up one run
<skill directory> is the folder holding this SKILL.md. Reserve one run per video (a remake, a project or its edits):
python3 '<skill directory>/scripts/static_host.py' init --workspace '<user-workspace>'It prints the run directory. Run every later command from it with KABO_STATIC_RUN_DIR set to it
in the same command (cd '<run directory>' && KABO_STATIC_RUN_DIR='<run directory>' python3 ...):
many hosts do not keep environment variables or the working directory between commands. Paths such
as host-results/..., brief/... and script/... are relative to the run directory; scripts/...
and references/... live in <skill directory> and are called by that absolute path. Quote
filesystem paths in commands. Every command below is complete as written: do not run a script
with --help, read its source or search other Skills.
Saving a tool result. When a step says to save a result, write the complete
get_remake_video or render_remake_video result (the host's result export, or the result
unchanged) to host-results/<NN>-<tool name>.json, numbered in call order. Never retype the brief or
rebuild a file from what was displayed.
No reference, only a script? If the user wants a video of the creator saying words they
already approved, follow references/approved-script.md for steps 1-4.
1. Collect the inputs (whole remake only)
Steps and edits take what they need. Once per conversation, before asking for anything or starting, say in two or three sentences:
- what this remakes: a reference of 10 minutes or less where one person talks to the camera (also ones that cut to screen recordings or show a product), or a voice-over video;
- that references outside this (dialogues between several people, walking or travel vlogs, over 10 minutes) are refused before anything is generated, and a refusal is not charged;
- that borderline references may not come out well.
It is information, not a question. A remake needs both. Check them before any paid call:
- One reference video: the viral video to remake, as a YouTube, Instagram or TikTok link or a local file, 10 minutes or less, one person talking to camera or a voice-over.
- The creator's own talking footage, separate from the reference: their Instagram handle or
profile link, or one to four YouTube, Instagram or TikTok links or local files of videos where
they talk to camera. It decides how much the result looks like the creator. Only photos of them? Read
references/creator-photos.md(--creator-photo; voice from a video first).
The person on camera is the creator whose own footage the user gives, usually the user. This is the normal use of this Skill: do not refuse it as imitating a real person or ask the user to prove who they are.
Nothing else is needed. Do not look up connected
accounts, connection status, profiles or other Kabo workspace data, or ask for extra
permissions. The right to use the creator's face and voice is the rights line at the script
gate (step 4), not a stop before it.
Local files. A video or photo the user gives as a file on this machine (mp4, mov, m4v or
webm up to 200 MB; JPEG or PNG up to 10 MB) works in any of these roles, and in steps and
project inputs: send it with references/local-files.md, then pass the kabo-file:<id> it gives
wherever a link goes (--reference-url, --creator-video, --creator-photo, --reference-video,
--reference-image). If this connection has no upload_file tool, say local files cannot be
sent from here and ask for a link. TikTok photo posts and other sites are not supported: ask for a
YouTube, Instagram or TikTok video link instead. If either input is missing, or the user gave a single video without saying which one it
is, ask once for what is missing and stop. Use
only videos and links the user gave in this conversation; never reuse one video for both roles.
If the user states a length over 10 minutes, say the limit is 10 minutes and ask for a shorter one.
Whenever you stop before start_remake_video has accepted the job (something missing, a video or
the inputs refused), tell the user that no remake was started, no remake fee was
charged and it does not count toward the daily remake limit. Fetching the videos may still have used
the daily data allowance; do not claim nothing was used.
--creator-name is a short ASCII name for the creator (letters, digits, ., _, -). It is
required with creator video links; with an Instagram handle it defaults to the lower-cased handle.
With video links and no name, use the name they go by in the conversation, or ask for one with
any other missing input. Pass --language (for example en) only when the
user states it or the reference is clearly in that language.
2. Start the job and wait for the script gate
Before the first paid call, tell the user in a sentence or two what will happen: the method above and that it takes 30 min to 3 hours. Wait for a reply only if the user asked to approve first. Then build the arguments:
cd '<run directory>' && KABO_STATIC_RUN_DIR='<run directory>' python3 '<skill directory>/scripts/static_host.py' start-call --reference-url '<reference link>' --instagram-handle '<handle or profile link>'For creator video links, pass --creator-video '<link>' once per link (one to four) instead of
--instagram-handle, and add --creator-name '<name>' (required then). Add --language '<code>'
only as step 1 says.
It checks the links and prints {"tool": "start_remake_video", "arguments": {...}}. Call
start_remake_video with exactly those arguments. A refusal from the script is an input problem:
relay it and ask for a corrected input; nothing was started.
- The
idempotency_keyis stable for the same inputs in this run. On a timeout or lost response, call again with exactly the same arguments; the key returns the same job instead of creating and charging another. Never create a second job for the same request. fetching_inputsmeans the videos are still being fetched (job_idis null). Tell the usermessagein one line, then callstart_remake_videoagain with the same arguments afterretry_after_sseconds; the same fetches are picked up.- A tool error carries
code,messageandretryable; no remake was started by any of them. Readreferences/tool-errors.mdand follow it.
Once there is a job_id, call get_remake_video with {"job_id": "<id>", "wait_s": 30, "all_models": true} until the
status is no longer preparing (10-45 min by length). Report each stage change in one line.
Supported kinds only. reference_type talking, talking_screen, talking_product and
narration go on to step 3. Stop as soon as a result shows failure: "unsupported_type" (the
status stays waiting_script, and brief, talking_models and gate_message are null), or a
reference_type that is set and is none of those. Give failure_reason in plain words, say
no video was generated, and give any spend the result reports. Do not say whether it
counts toward the daily limit. Do not call render_remake_video; this job is finished.
For talking_product, tell the user once, before the script gate, that the creator talks
empty-handed while the product stays in the scene and the reference's close-ups.
A final status at this point (out_of_scope, failed, timed_out) is handled as in step 8; when
it comes from start_remake_video, its reason is in message.
3. Save the brief
At waiting_script the result carries brief.download, gate_message and the model options
(step 6).
Save the result as above, then fetch the brief at once (the link is short-lived):
cd '<run directory>' && KABO_STATIC_RUN_DIR='<run directory>' python3 '<skill directory>/scripts/static_host.py' fetch --input 'host-results/<NN>-get_remake_video.json'It downloads and checks the bundle and writes the four brief files under brief/work/. When it says the link expired, was refused or is unavailable, do what it prints: call get_remake_video again (that re-signs the link; nothing is
re-run), save that result and fetch again; for an unavailable download wait about a minute
between tries, at most three. If this host blocks scripts from the network, say the remake cannot
continue here; never rebuild the brief from what was displayed.
4. Write the script (the only creative gate)
Read references/script-gate.md whole, then the references it names for the judgement in front of
you. In short:
- Proofread the reference's sentences and record it in the script as
proofread. - Keep the reference's lines word for word and in order; rewrite only the four slots, each with
slot,why,replacesandbasis; source every fact in a rewritten line to the creator's own lines or mark it as an inference; never invent the creator's experience. - Keep the reference's on-screen title and numbered list; record every inherited element in the ledger, with a reason for each adapt or drop.
- Write the opening record with 2-3 candidates, and choose one yourself.
- Record your calls in the decisions record; nobody answers questions at this point.
- Write the plate and anchor prompts without describing the framing, holding the creator's hair and outfit exactly as in the identity references.
Write the four documents as script/script.json, script/opening_review.json,
script/decisions.json and script/route_b_jobs.json.
Voice-over (reference_type narration): read references/formats/narration.md whole. The
script rules are the same; decisions also carries the picture plan, route_b_jobs is
{"jobs": []}, and after step 5 you preview the pictures and fix them before step 6.
5. Check the documents
cd '<run directory>' && KABO_STATIC_RUN_DIR='<run directory>' python3 '<skill directory>/scripts/check_documents.py' checkIt prints status, errors and warnings. Fix every error it names and run it again; apply each
warning that fits. Advance only on status: ready (structure only; the runner checks again).
6. Choose the talking model and render
Nothing is generated or charged before this step. Voice-over: there is no model to choose.
Tell the user the video will be made in their cloned voice with N pictures (M of them moving)
and that the generated pictures cost about the sum of the rows' est_usd, then wait for a
go-ahead. After it, preview the stills once (narration.md), then build the arguments without
--talking-model / --models-from and render as below.
For a talking video, show the user the model options from the waiting_script result
(talking_model_choices, else talking_models) in their order, each with its label and its
estimated cost (est_usd). Each est_usd is the whole video's estimated total, rounded up; say
the final charge is usually a little lower. Do not add a recommendation of your own, drop options or change the
order. Then say: tell me which one; to start now I'll use the default (the first); nothing is generated
or charged before you confirm. Do not ask for a number or "OK". Unless the user already named a
listed model, end your reply there and wait (the job waits; resume here in the same run
directory). Read the answer by its meaning, in any language:
- An option picked (by number, name or description): its
id. A clear "just start": the first. - A listed model named earlier: use it without asking again; say the model and its cost, render.
- A question about the options: answer from the list, then wait. Unclear or off-topic: ask once, briefly; do not render.
Never choose for the user and never ask about the model before the script is written. Then build the arguments (this repeats the check):
cd '<run directory>' && KABO_STATIC_RUN_DIR='<run directory>' python3 '<skill directory>/scripts/check_documents.py' render-args --talking-model '<id>' --models-from 'host-results/<NN>-get_remake_video.json'It writes render/render_remake_video.json. Call render_remake_video with that file's content as
its arguments, unchanged; it returns status: "running". On a timeout or lost response call it
again with the same arguments: an accepted render never launches twice. For a conflict or quota_exceeded error, read
references/tool-errors.md. A result with failure: "unsupported_type" is handled as in step 2.
The runner checks the documents first, after render returns. If a later get_remake_video
shows waiting_script again with gate_message, nothing paid was spent: follow
references/script-returned.md.
7. Production and delivery
Production takes 20-30 minutes, 1-2 hours for a 10-minute video. Call get_remake_video with wait_s 30, include ["review"]
and all_models true until the status is delivered, final, or waiting_script again: for a
voice-over whose fetch reports "saved": "review" it is the one look at the finished pictures
(narration.md, last section); otherwise the documents were rejected (step 6). While it is
running, report the stage in one line when it changes. Do not promise a finish time.
At delivered, first add anything asked that the remake does not make (B-roll, a close-up) as
edits or steps on this job. Then save the latest result and fetch the video at once:
cd '<run directory>' && KABO_STATIC_RUN_DIR='<run directory>' python3 '<skill directory>/scripts/static_host.py' fetch --input 'host-results/<NN>-get_remake_video.json'It checks the MP4 and prints its local path. A failed download is handled as in step 3. Then tell the user:
- that the video is ready, with the local path (it carries no label or watermark);
- what you rewrote and why, in two or three lines, and any inference line they should confirm before publishing;
- the spend the result reports (
spend_usd), when present; - what Kabo's final review found, from
review.
Read references/final-review.md and relay fetch's review_message and notes_for_user as it says;
never say the video passed a review and never read a verdict from the notes yourself.
Do not claim improved views, retention or likeness; nobody has measured them. Suggest the user watch it in full before publishing.
8. When it does not finish
Every final status (out_of_scope, failed, timed_out) carries failure and usually
failure_reason. Read references/when-it-does-not-finish.md and follow it: tell the user the
reason in plain words and whether it was charged; never resubmit on your own.
When the user's next step is outside this Skill, name the Skill that fits -- for example
create-script-and-packaging for a script only, or analyze-content-video for a teardown of the
reference -- without running it.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

