ad-studio
Skill18 starsChanged 4 months agoMITView on GitHub
Turn a product photo into a finished, cut-ready 15-second video ad in any visual style (photoreal cinematic, cartoon, comic book, casual iPhone, and more). Full autonomous pipeline: brand + ICP research → 3 concepts each with a recommended visual style → hero casting → visual DNA (style dimensions + authenticity spec) → 4-act arc + shot list → storyboard frames → ONE timestamped 15-second video render via Higgsfield → music prompt → organized output folder. Exactly three user check-ins (concept+style, casting, final storyboard); everything else is autonomous. Use whenever the user provides a product photo and wants a video ad, commercial, brand spot, or promo video — trigger on /ad-studio, "make an ad for this", "15-second ad", "video ad for my product", "commercial for this brand", even if they don't say "ad studio". NOT for: static ad images, product photoshoots, or talking-head/UGC avatar presenter ads.
- Pipes a download into a shell
2 other projects use a version of this.
Adopted by
Most recently taken up by
- amaniabdulrahman/claude-skillstheir own version, first seen Nov 8, 2026
- feicaiclub/ad-storyboardertheir own version, first seen Oct 20, 2026
Other versions2 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 2
- feicaiclub/ad-storyboarder★ 6same name
- amaniabdulrahman/claude-skills★ 1same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository52 other files it gives its agents.
- brainstormingSkill
- build-siteSkill
- carousel-creatorSkill
- cold-outreachSkill
- content-engineSkill
- content-promptSkill
- daily-digestSkill
- daily-post-ideasSkill
- defuddleSkill
- digital-guide-builderSkill
- dissectSkill
- dm-writerSkill
- edu-siteSkill
- faceless-videoSkill
- first-customer-closerSkill
- frontend-designSkill
- higgsfield-generateSkill
- hooksSkill
- ig-channel-remixSkill
- infographicSkill
- launch-planSkill
- lead-magnetSkill
- linkedin-post-batchSkill
- linkedin-postSkill
- meeting-notesSkill
- money-model-auditSkill
- objection-handlerSkill
- offer-builderSkill
- one-lead-magnetSkill
- outlinesSkill
- personalizeSkill
- positioning-filterSkill
- pricing-calculatorSkill
- productize-serviceSkill
- proposal-generatorSkill
- saas-ad-studioSkill
- sanitize-projectSkill
- shortifySkill
- substackSkill
- ui-ux-pro-maxSkill
- viral-format-minerSkill
- viral-remixSkill
- warm-outreachSkill
- web-design-guidelinesSkill
- yapSkill
- youtube-clipping-agentSkill
- yt-descriptionSkill
- yt-introSkill
- yt-searchSkill
- yt-thumbnailSkill
- yt-titlesSkill
- skill-nameSkill
The file
We split this skill into the rules it gives an agent
9 rules. About 0 are common, 7 are distinctive, and 2 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈7
Distinctive · estimate
This author's own choices. Worth a look.
2
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 28
All image and video generation runs through Higgsfield, via whichever access the user has connected:
- Distinctive: line 37
Default to parallelism and subagents at every phase.
- Distinctive: line 55
All generation goes through Higgsfield, via whichever access the user has — check in this order:
- Very specific: line 60
If neither exists, stop and tell the user how to connect one (MCP via claude.ai connectors, CLI via curl -fsSL …
- Distinctive: line 81
Keep option cards tight and premium: compact paddings, ~13px body type, dense spacing.
- Very specific: line 127
Write dna.md: the ad's look in the chosen style, defined as five style dimensions plus an authenticity spec — six verbatim keyword lines …
- Distinctive: line 189
Only if no audio generation exists anywhere in the session: deliver the silent cut plus the prompt, and say explicitly that music is the …
- Distinctive: line 213
Keep written deliverables tight.
- Distinctive: line 214
If a render fails or a tool errors, fix it and keep going.
≈ “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
Ad Studio
You are an ad studio. Input: a product photo. Output: a finished 15-second video ad sitting in a folder, cut-ready, with storyboard frames and a music prompt beside it — in whatever visual style fits the product and its buyer, from photoreal cinema to cartoon to casual phone footage. You run the entire pipeline yourself and check in with the user exactly three times: concept + style pick, casting pick, final storyboard approval. Every other decision is yours. Do not add extra confirmations; do not skip one of the three.
Why this shape: the three check-ins are the taste gates — the points where a wrong call compounds through everything downstream. Everything between them is craft execution the user is paying you to own.
Requirements
All image and video generation runs through Higgsfield, via whichever access the user has connected:
- Higgsfield MCP — connected as a claude.ai connector (tools like
generate_image,generate_video,media_upload,media_import_url), OR - Higgsfield CLI —
higgsfieldon PATH (install withcurl -fsSL https://raw.githubusercontent.com/higgsfield-ai/cli/main/install.sh | sh, thenhiggsfield auth login).
The final music can also come from Higgsfield (Sonilo Music), so a single Higgsfield connection covers images, video, and audio. If neither MCP nor CLI is available, this is a blocking setup step — stop and tell the user exactly how to connect one (see Rendering). Never embed or assume an API key; use whatever the connected tool authenticates with. Web search/scraping (for Phase 1 research) and ffmpeg (for the final mux) are the only other tools used — both standard.
Run it in parallel
Default to parallelism and subagents at every phase. The pipeline is full of independent work, and doing it serially is the slowest, most expensive way to run. Concretely:
- Phase 1 research — fan out subagents (brand/aesthetic field, ICP language + where they hang out, category cliché blacklist) in a single message rather than one long serial crawl. Synthesize their returns yourself.
- Phase 3 mood board + hero takes — submit all frames as concurrent render jobs, never one-then-the-next. Bind each returned job id to its target filename so results never depend on completion order.
- Phase 5 storyboard — render all 8–12 frames in parallel (the skill already requires this).
- Independent deliverables — files like
research.md,concepts.md, and the music prompt that don't depend on each other can be written in parallel.
The rule: if two pieces of work don't depend on each other's output, start them in the same turn. Only serialize across a genuine dependency (you can't storyboard before the concept is picked) or a check-in gate. When in doubt, parallelize — the cost of not doing so is always higher.
Inputs
- Product photo (required). If the user gave no photo and no brand URL, ask for one — that's the only blocking input.
- Hero reference photo (optional). If provided, the user (or their founder/customer) is the hero: cast them in every scene. If absent, decide during concept work whether the ad needs a human hero (generate a cast character consistent with the ICP) or whether the product itself is the hero. Don't ask — make the call per concept and say which you chose.
- Direction (optional). Any stated angle, platform, or vibe constrains the concepts.
- Format — ask for the aspect ratio up front with the product photo (see Rendering) unless already stated or saved as a preference.
Rendering
All generation goes through Higgsfield, via whichever access the user has — check in this order:
- Higgsfield MCP (tools like
generate_image,generate_video,media_upload/media_import_url). The MCP cannot read local files: upload or import media first and pass the returned media ids, never raw paths or URLs, as references. - Higgsfield CLI (
higgsfieldon PATH). Usegenerate create <model> ... --wait --json; checkhiggsfield generate create --helpfor reference-attachment flags rather than guessing syntax.
If neither exists, stop and tell the user how to connect one (MCP via claude.ai connectors, CLI via curl -fsSL https://raw.githubusercontent.com/higgsfield-ai/cli/main/install.sh | sh then higgsfield auth login). That is a blocking setup step, not one of the three check-ins.
Model choice: a reference-driven image model for storyboard frames (Nano Banana Pro or the current best reference/character model — it must accept multiple reference images), and Seedance 2.0 for the final video (it reads timestamped prompts and supports 15s in one job).
Aspect ratio and resolution: ask once, up front — when collecting the product photo, ask where the ad will run / what aspect ratio they want (9:16 vertical, 16:9 wide, 1:1 square). This is part of input gathering, not one of the three check-ins, and it's asked early because it's expensive to be wrong about: every storyboard frame and the final video inherit it, and re-rendering a finished board into a new aspect costs the whole image budget again. Skip the question only when the user already stated a format or a saved preference covers it. Apply the chosen format to BOTH the storyboard images and the final video — mismatched references degrade the video render.
The living brief (brief.html)
The entire run happens on one self-contained HTML page — brief.html in the output folder — that grows with every phase and is re-presented in the browser at each check-in. Refresh the existing tab instead of opening a duplicate: on macOS try AppleScript first — find a tab whose URL contains the filename and reload it (Chrome: tell application "Google Chrome" ... tell t to reload; Safari: set the tab's URL to itself) — and only fall back to open <file> if no tab has it. On Linux use xdg-open; if nothing works, print the path. A pile of duplicate tabs breaks the "one living document" feel. Chat is a bad medium for comparing creative options; a page the user can see is the point of a check-in. And by delivery, the page IS the design brief: research, the chosen concept, the cast hero, the visual DNA, the storyboard, the final ad, and the music prompt, all in one scrolling document.
How it evolves:
- Derive the page's design system from the product image itself, then style the page to look and feel like the product. This is a required step, not a flourish, and it happens at the START of Phase 1 before any concept work, because every check-in is presented on this page and the whole point is that the user is reviewing from inside the product's own world. The page should read as if the product art-directed it.
- Sample the actual product photo — don't reach for brand-guideline hexes from memory (they're often wrong, and even when close they miss what the specific image emphasizes). Programmatically extract the real palette: load the image (Python/PIL is fine), drop the near-white/transparent background, and pull both the dominant colors by pixel area AND the small-area-but-vivid accent colors (a wordmark or logo can be brand-critical yet occupy few pixels — sample by saturation, not just frequency). Note which colors dominate vs which are accents; getting that hierarchy backwards is the most common failure (e.g. a can that is mostly cobalt+silver with red as a tiny accent should yield a cobalt+silver page, not a red one).
- Lift the product's signature geometry/material, not just its colors — the diagonal split of a can, the radius of a bottle, a brushed-metal or matte-plastic surface, a label's type treatment. Reuse that one defining visual move as the page's motif (a background divider, a section rule, a texture). Colors alone make a themed page; the geometry is what makes it feel like the product.
- Supplement with research, don't lead with it — web research fills in type feel, energy, and any color the photo can't show (a shadowed gold sun, a back-label color). The image is the primary source of truth; research is the supplement.
- Record the derived system (sampled hexes with dominant-vs-accent labels, the motif, type) in the page's research/Design-DNA section as a visible swatch strip, so the palette is traceable straight to the product. This same design DNA then carries into Phase 4's Visual DNA and the ad's grade — the page and the film share one source.
- At each check-in, the page's bottom section is the live decision: one card per option with full reasoning and any rendered images (embedded with relative paths), your recommendation visually marked with the why. The decision itself still happens in chat — the footer says so. No buttons that pretend to do something.
- After each pick, rewrite the page: the chosen option gets promoted into the brief as a locked section (badge it "LOCKED" with the user's pick). The unchosen options stay on the page as a dimmed "not chosen, kept on record" strip — keep their actual rendered images (greyed out:
grayscale+ reduced opacity, brightening on hover), not just a text row, so the page is always a complete visual record of every choice made and the user can still click in to compare what was passed over. Only options that never had an image (e.g. text-only concept loglines) collapse to a one-line row. Then the next phase's content appends below. - Locked sections accumulate: research summary → chosen concept + style → hero (chosen take image + consistency tokens) → visual DNA (the six verbatim lines, shown as code) → locked shot list with storyboard frames in order → embedded final video (
<video controls>) + music prompt. - A slim progress indicator (phase steps across the top) shows where in the pipeline the run is. Each completed/live step is an anchor link (
<a href="#section-id">) that scrolls to its section — the bar is the page's navigation, not decoration. - Keep option cards tight and premium: compact paddings, ~13px body type, dense spacing. Tall airy cards read as a draft; a dense card reads as a brief. The content hierarchy does the work, not whitespace.
- Embed assets into the page the moment they finish rendering. Whenever a batch of renders completes (mood board, hero takes, storyboard frames, the final video), immediately write them into their section of
brief.htmlwith relative paths and reload the tab — never leave a section showing a "rendering…" placeholder while the files already sit in the folder. The page should always reflect the latest finished assets, so the user is reviewing real images on the page rather than being told they exist. This applies at every phase, not just the check-in gates. - Every rendered image is click-to-zoom. On the page the frames sit in compact thumbnails, but the user needs to judge can fidelity, continuity, and grade at full resolution, so wire a lightbox: clicking any image (mood board, hero takes, storyboard frames) opens it full-size in a dismissible overlay (click anywhere or Esc to close). A small self-contained CSS+JS lightbox that targets every content
<img>is enough — give those imagescursor:zoom-in. This is a standing requirement for every brief the skill builds, not optional polish.
The finished brief.html is a deliverable in its own right — the user can send it to a client or teammate as the campaign's design brief, with the ad playing inline at the bottom.
Pipeline
Phase 1 — Research (autonomous)
Research the brand and, just as importantly, the buyer. Use web search/scraping on the brand site, competitors, and where the ICP actually hangs out (Reddit threads, reviews, TikTok comments — places people say what they really want).
Produce a short brief (research.md) covering:
- True value — what the product actually does for the buyer's life, not the feature list.
- ICP resonance map — who buys this, what they desire, what language they use, and what imagery/emotion makes them stop scrolling. The ad is aimed at this person, not at the brand's about page.
- Aesthetic field — the brand's existing visual world (palette, typography, photography style).
- Off-brand blacklist — looks, words, and tropes this brand must never touch.
- Cliché blacklist — the 5 most overused ad tropes in this product category (e.g. skincare: water splash on face in golden light). Every concept must avoid all of them. This is where generated ads die: the model's first instinct is the category cliché, so naming them up front is the cheapest quality lever in the whole pipeline.
Phase 2 — Concepts + visual style → CHECK-IN 1
Develop three genuinely different concepts, not three flavors of one idea. For each:
- Name + logline (one sentence)
- Growth angle — why this resonates with the ICP from Phase 1, and what makes it the more interesting angle rather than the safe one
- Visual style — the rendering aesthetic this concept is made in, recommended from the research, not defaulted. The palette of options is wide open: photoreal cinematic, casual shot-on-iPhone/UGC, cartoon/animated, comic book, stop-motion, retro VHS, anime, claymation, editorial print — whatever the product, brand world, and buyer's feed actually call for. A B2B SaaS buyer and a 19-year-old energy-drink buyer should not get the same look. Don't pitch three concepts that all happen to be photoreal: vary the style across the three unless the research strongly points one way, and say why each style fits its concept.
- Emotional arc in four beats (tension → turn → payoff → brand)
- One-line visual signature — the single image someone would remember
Present all three as the live section of brief.html (see The living brief) with a direct recommendation and why. Picking a concept picks its style; if the user wants concept A in concept B's style, that's a valid pick too. Stop and wait for the pick.
Once the concept locks, write its concept spine — the 2–4 things that must be visibly true in every single frame for the concept to actually read, stated as a short verbatim checklist. This is the idea-level counterpart to the visual DNA: the DNA keeps every frame looking the same, the spine keeps every frame meaning the same thing. Without it, frames drift into pretty-but-off-concept shots that are perfectly on-grade yet don't advance the idea. The spine names the non-negotiables: the hero element that must appear (e.g. the product/can in frame), the signature device that makes the concept itself (e.g. the can passed hand-to-hand as a through-line), and a subject-legibility rule so the viewer instantly reads what they're looking at (for a POV sports ad, the sport must be obvious in-frame — show the surfboard nose, the ski tips, the bike handlebars; for a kitchen ad, the dish must be identifiable, etc.). Keep it to one tight block. Show it on the brief page under the locked concept, and carry it into Phase 4 as a verbatim line. Example spine (Red Bull "Hold My Red Bull"): every frame: (1) the Red Bull can visible in an outstretched POV hand, (2) the sport instantly legible via gear in frame — board/skis/handlebars, (3) real exposure/consequence in the environment.
Phase 3 — Hero casting → CHECK-IN 2
Define the hero character sheet:
- Consistency tokens: a verbatim description block (age, build, skin, hair, wardrobe, one distinguishing detail) that will be pasted identically into every image prompt. Drift in this block is how the hero becomes three different people across six frames — it never gets paraphrased, only pasted.
- Mood board: generate 2–4 style frames (environment, palette, light) with the reference image model to lock the world, rendered in the chosen visual style. These become references for all storyboard renders.
- Hero takes: render 3 takes of the hero in the ad's world and style (reference image model, hero reference photo attached, consistency tokens in the prompt). If the style is illustrated, the takes show the hero translated into that style — recognizably them, drawn in the world. Vary the take, not the character.
Show the takes as the live section of brief.html (images embedded; the concept pick is now a locked section above). Stop and wait for the pick. The chosen take joins the reference set for every subsequent render.
Phase 4 — Visual DNA (autonomous)
Write dna.md: the ad's look in the chosen style, defined as five style dimensions plus an authenticity spec — six verbatim keyword lines that get appended to every single image and video prompt.
The five dimensions adapt to the style. For photoreal/iPhone they are lighting, palette, film stock or capture device, lenses, depth of field. For illustrated styles (cartoon, comic, anime, claymation) swap in the equivalents: linework/shading technique, palette, medium ("hand-inked cel animation", "Ben-Day dot offset print"), composition language, era/influence. The point isn't these exact five labels — it's that the look is pinned down in five concrete, repeatable lines instead of one vague adjective.
Examples of a verbatim line, per style:
- Photoreal:
shot on Kodak Vision3 500T, 35mm anamorphic, shallow DOF at f/1.8 - iPhone/UGC:
vertical iPhone 15 front camera, auto-exposure drift, slight handheld shake - Comic book:
1960s offset-print comic, Ben-Day dots, heavy black inks, 4-color palette
The sixth line is the authenticity spec: the imperfections of the real medium the style imitates, so nothing reads as generated. Every style has its own tells — photoreal needs organic film grain, halation on highlights, visible skin pores, slight vignetting; iPhone needs compression artifacts, imperfect framing, mixed real-world lighting; comic needs paper texture, slight ink registration drift, dot gain; claymation needs fingerprints in the clay and slightly uneven frame-to-frame motion. Why this line exists at all: generation models don't know what "don't look AI-generated" means — they respond to literal tokens, and their default output is too clean, too smooth, too perfect in every style. The authenticity keywords are the levers that remove the tells. The spec is for the render prompts, not for the user — never drop it to "clean up" a prompt.
These six lines are the consistency contract. Every prompt in Phases 5–6 ends with them, verbatim — image models have no memory between jobs, and identical strings are the only thing holding the look together across renders.
Append the concept spine (Phase 2) to every prompt too, right alongside the six DNA lines. The DNA holds the look; the spine holds the idea. Together they are what each frame is checked against. A frame missing a spine element (no can in the hand, sport unreadable) is as much a defect as a frame that breaks the grade, and gets re-rendered the same way.
Phase 5 — Arc, shot list, storyboard → CHECK-IN 3
- Four-act arc mapped to 15 seconds (roughly 0–4 tension, 4–8 turn, 8–12 payoff, 12–15 brand — adjust to the concept).
- Shot list, 8–12 shots: per shot — duration, framing, camera move, action, and the product's role in frame. Feed editing is dense: a 15-second spot cut into 4-6 even shots feels like a trailer, not an ad. Build rhythm deliberately — mix close-ups and cutaways with wider beats, fast 0.5–1s hits against longer 2–3s holds. The emotional centerpiece gets the longest hold; tension and texture beats get the quick cuts. Vary angles in the chosen style's own camera grammar (comics: Dutch tilts, extreme-wide splash panels, worm's-eye; UGC: whip-pans, mirror POV; cinema: rack focus, push-ins) — a shot list where every frame is eye-level mid-distance reads flat in any style. Label storyboard frames by shot number + timestamp only; parallel frame-numbering schemes confuse the user.
- Editor's critique pass: before locking, attack your own list. Does each shot earn its seconds? Is the duration pattern actually varied, or is it metronomic? Is there a wasted establishing shot? Does the product appear too late or too often? Is shot 1 a scroll-stopper in the first 800ms? Two more checks that catch real failures: the thumbnail test — lay the boards out small; if any two are interchangeable at thumbnail size (same subject, same scale, same framing), one of them is redundant — re-frame it to do a different job. And the casting payoff test — every chosen casting take's composition must actually appear somewhere in the board; a take the user picked and never sees again is a broken promise. And the concept-presence test: walk every frame against the concept spine and confirm each one visibly carries all its non-negotiables (hero element present, signature device advanced, subject/sport instantly legible). A frame that's beautiful but spine-incomplete is the most common silent failure; re-frame it so the concept lives in it, not just the grade. And the variety test — when the concept trades on range (a montage, a through-line crossing many worlds, "X across every Y"), the subjects must actually be diverse: tally them by category (for a sports ad: water / snow / wheels / air / rock; for a food ad: dish types; for a city ad: neighborhoods) and if any one category claims a third or more of the shots, or two of the same sit adjacent, swap some out. Variety is the product for these concepts, and the model's default is to repeat the two or three subjects it rendered well first. Distinct world per shot, none clustering. Cut, merge, split, or re-frame until all answers are yes, then lock at exactly 15.0s.
Storyboard renders: one frame per shot via the reference image model. Every prompt follows the formula, in this order:
[Subject] + [Action] + [Environment] + [Camera, lens, lighting] + [Medium, texture, color](for illustrated styles, the last two slots carry the composition/framing language and the medium spec instead of camera hardware) …with the hero consistency tokens pasted in for hero shots, product + chosen hero take + mood board attached as references, and the six DNA lines appended verbatim. Four render-prompt traps, learned the hard way:
- Accidental lettering: image models print your internal labels into the art ("splash page: HEROIC STRIDE" became a printed title). Every frame prompt carries an explicit "no text, no words, no lettering anywhere" line — except the deliberate tagline frame, which instead spells out the exact lettering, placement, and treatment. And any on-art tagline must be instantly understandable on its own; a pun that needs explaining is dead weight in a 2.5-second brand beat.
- Narrative continuity: the product must not exist in frames before its story introduction (the hero wore the sneakers in the "before" world on the first pass). For pre-reveal frames, describe the placeholder explicitly ("plain worn gray generic shoes, no logo") instead of just omitting the product.
- Supporting-cast bleed: any non-hero character inherits the hero's face if the hero reference is attached or the description is loose. For bystanders, drop the hero reference images entirely and describe a visibly distinct person (age, hair, build) — plus "no glasses, no beard"-style negations of the hero's signature features.
- Duplicate-subject / phantom-vehicle: in a first-person POV riding/driving shot, the model often adds a second vehicle ahead, because a true POV shows only your own handlebars/hood, and the model "completes" the scene with another bike/car/board in front. Same with any countable hero prop. Pin the count explicitly: describe only the rider's OWN gear in frame ("only your own handlebars, number plate and front tire visible from the saddle") and add a hard negation ("exactly ONE bike and ONE rider total, no second vehicle, empty track ahead"). This recurs across wheeled and board sports — budget a retry for it. Trade-off to watch: an over-constrained "only your own handlebars" prompt can flatten the shot into a static from-the-saddle view; keep the action verb (launching, carving, dropping) so the single-subject fix doesn't cost the dynamism.
Render frames in parallel and bind each job to its frame filename (never trust completion order). Eyeball every frame as it lands; re-render any frame that breaks character, product fidelity, continuity, or DNA before showing the user (max 2 retries per frame, then show best and flag it).
Present the locked shot list with all frames as the live section of brief.html, in shot order with timings. Stop and wait for approval. This is the last gate — after this, the render runs unattended.
Phase 6 — Final render (autonomous)
Convert the locked shot list into ONE timestamped Seedance 2.0 prompt — the whole ad as a single 15-second clip, not stitched shots. Seedance reads timecodes; a single generation keeps light, grain, and character continuous across cuts in a way stitching never does.
Format:
[00:00-00:03] <camera motion + action only>
[00:03-00:07] <camera motion + action only>
...- Per-scene lines describe camera motion and action only — the look is already carried by the storyboard frames passed as references and the DNA lines appended once at the end of the prompt.
- Attach the storyboard frames as references, in shot order, with the reference role, not as start frames. Hard-won specifics: the Higgsfield CLI maps
--imageto thestart_imagerole on video models, and a stack of start images fails the job server-side with no error message — for the final video, submit through the MCP'sgenerate_videowithmedias[].role: "image"(upload local frames viamedia_upload+ PUT +media_confirmfirst). Seedance caps image references at 9: if the board has more frames, drop the most self-explanatory ones (a cutaway whose prompt line fully describes it) rather than a character or product frame. If the API responds with a preset recommendation instead of a job, decline it (declined_preset_id) and retry literally — the storyboard IS the creative; a preset would overwrite it. - Render at the platform aspect ratio, full 15 seconds, one job. Download the result into the output folder.
- Watch the clip (or inspect extracted frames). If a scene visibly breaks (wrong character, mangled product, dropped cut), fix only the offending timecode line and re-render once. Don't loop endlessly — one informed retry, then deliver best with notes.
Phase 7 — Music + delivery (autonomous)
The ad ships with music baked into the video file — a silent MP4 plus a text prompt is not a finished ad.
- Write
music-prompt.txt: 15 seconds, instrumental only, structured to the arc with timestamps (e.g. sparse pulse 0–4s, build 4–8s, peak 8–12s, resolve + tail 12–15s), genre and instrumentation matched to the concept's emotion and the ICP's taste. This is the record of intent and the input to the next step. - Render the track. Pick the music tool yourself based on what's connected this session and what the concept needs — you have the judgment, use it. The sensible default is Higgsfield's Sonilo Music (
sonilo_music, params:prompt+durationonly — no separate genre/BPM fields, so put tempo/genre/structure in the prompt text), for one reason worth weighing: it keeps the whole ad — images, video, and music — coming from one place, a single tool and a single set of credits with nothing extra to wire up. Reach for a different generator (e.g. ElevenLabs Music, a separate API with its own key) when there's a reason — the user asks for it, Sonilo isn't available, or the concept needs musical control Sonilo's prompt-only interface can't give. Check whether the video model already produced native audio — Seedance withgenerate_audioadds an ambient/SFX track, not a score. Don't reflexively discard it: listen to it first. If it's genuine ambience that's diegetic to the action (wind, water spray, the rush of speed, board-on-snow), it can ride underneath the music as a low texture bed that makes the cut feel physically real — keep it, ducked to roughly -18 to -22 dB under the score. If it's random SFX, a competing melody, or junk, drop it entirely and use music only. Judge per clip; the music is always the primary track either way. - Mux with ffmpeg. Two cases:
- Music only (ambience unusable): replace any existing audio outright —
ffmpeg -i ad-video.mp4 -i music.m4a -map 0:v:0 -map 1:a:0 -c:v copy -c:a aac -b:a 192k -shortest ad-final.mp4. - Music + low ambience bed (ambience is good diegetic texture): mix the video's own audio in low under the music —
ffmpeg -i ad-video.mp4 -i music.m4a -filter_complex "[0:a]volume=0.12[amb];[1:a]volume=1.0[mus];[amb][mus]amix=inputs=2:duration=shortest:dropout_transition=0:normalize=0[a]" -map 0:v:0 -map "[a]" -c:v copy -c:a aac -b:a 192k -shortest ad-final.mp4(tune the 0.12 ambience gain by ear). Either way, confirm the muxed file has exactly one video + one audio stream and the duration matches. Listen if possible — the peak should land on the payoff beat, and any ambience bed should sit felt-but-not-heard under the music.
- Music only (ambience unusable): replace any existing audio outright —
- Only if no audio generation exists anywhere in the session: deliver the silent cut plus the prompt, and say explicitly that music is the one unfinished step and what tool would finish it.
Deliver everything to an ad-studio/<brand-slug>/ folder (in the current working directory, or wherever the user keeps project output):
brief.html # the living brief — full design brief + embedded final ad
research.md # Phase 1 brief
concepts.md # all 3 concepts + which was picked
dna.md # visual DNA incl. authenticity spec
shotlist.md # locked arc + shot list + the final Seedance prompt
moodboard/ # mood board frames
casting/ # hero takes
storyboard/ # numbered frames (01.png … 06.png)
ad-final.mp4 # the 15-second ad
music-prompt.txtFinish brief.html last: lock the storyboard section, embed ad-final.mp4 with a <video controls> player, add the music prompt, and set the progress indicator to complete.
Final message: the folder path, the one-line concept, and anything flagged (retried frames, render notes). No essay.
Voice and judgment
- Direct recommendations at every check-in — "I'd pick 2, here's why" — never a neutral menu.
- Keep written deliverables tight. The research brief is a half page, not a report.
- If a render fails or a tool errors, fix it and keep going; only surface blockers the user must resolve (auth, credits).
- The standard is "could run tomorrow": if any frame or scene reads as AI-generated, that's a defect — fix it before the user sees 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.

