SkillAgentSearch skills...

scenario-game-ua-ads

Use when making a finished mobile game user-acquisition (UA) video ad with Scenario at an exact length for TikTok, Reels, Stories, Meta feed, YouTube Shorts, or ad networks: from a one-line concept or the game's own screenshots, screen recording, gameplay video, characters, icon, or UI kit.

Install / Use

npx skills add scenario-labs/skills --skill scenario-game-ua-ads

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

86/100

Category

Marketing

Supported Platforms

Universal

Tags

Our assessment of scenario-game-ua-ads

scenario-game-ua-ads scores 86/100 on our quality scale, 408th of 642 Marketing skills we index.

Its SKILL.md is 15 KB long, well organised into 11 sections and no code examples: a thorough specification that gives an agent plenty to work with.

With 1,048 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
30/30
Structure
13/20
Description
15/15
Adoption
13/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 29 days ago, so scenario-game-ua-ads is actively maintained.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-10. Automated pattern scan on 2026-11-10. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

scenario-game-ua-ads compared with similar skills

All 4 of these similar skills score higher than scenario-game-ua-ads; compare them before choosing.

SkillScoreStarsUpdatedFormat
scenario-game-ua-ads (this skill)by scenario-labs861.0k29d agoSKILL.md
x402by browser-use100121.0k3d agoSKILL.md
algorithmic-artby anthropics100177.9k55d agoSKILL.md
pptxby anthropics100177.9k55d agoSKILL.md
designby nextlevelbuilder100149.0k6d agoSKILL.md

Frequently asked questions

How do I install scenario-game-ua-ads?
Run npx skills add scenario-labs/skills --skill scenario-game-ua-ads. The install tabs above show the steps for each supported agent.
Which AI agents does scenario-game-ua-ads work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is scenario-game-ua-ads safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is scenario-game-ua-ads still maintained?
The repository was last updated 29 days ago, so scenario-game-ua-ads is actively maintained.

name: scenario-game-ua-ads description: "Use when making a finished mobile game user-acquisition (UA) video ad with Scenario at an exact length for TikTok, Reels, Stories, Meta feed, YouTube Shorts, or ad networks: from a one-line concept or the game's own screenshots, screen recording, gameplay video, characters, icon, or UI kit. Pin-pull, parking jam, match-3, swallow hole, evolution runner, stacker, draw to protect, odd one out, gacha, merge. Also hook, hand, HUD counter, end card. Not for ads from a product photo." license: MIT

Scenario Game UA Ads

Overview

A UA ad that plays like gameplay: Scenario generates or adapts the board art and the motion, and every piece of game UI is composited on top. The deliverable is the requested length and format at final render quality, never a draft or a single clip. The test of every beat: a stranger who has never heard of the game thinks "I really want to try this". For ads from a product photo, use scenario-video-ads; for hook, CTA, or end-card variants of a finished ad, scenario-ad-variants. Connection, discovery, and recovery follow scenario. If a sibling skill named here is missing from your available skills, load it with skill_get (Scenario MCP) or ask the user to install it (https://github.com/scenario-labs/skills#install); unattended, proceed from tool schemas and flag the gap.

Brief: ask once, then run

Ask in one round, then run without stopping:

  • Concept or the game's core loop, and the game name. Invent a fictional name when none is given.
  • Platform and placement. They fix the ratio, safe zones, recommended length, and sound (platforms).
  • Exact length in seconds. Without one, use the placement's recommended UA length.
  • The game's own material, all optional (inputs): screenshots, a screen recording or gameplay video, characters and items, the app icon, logo, or UI kit.
  • Palette and spend ceiling.

With the game's own material, the ad must look and play like that game: boards built from its screenshots, its characters on-model, its real icon on the end card. Invent gameplay only when the user has none to give.

dry_run every paid payload before the first billed run, plus retakes; over the ceiling, cut takes or ask. Unattended with no ceiling, stop at the plan and estimate.

Quick reference

| Stage | What happens | Sibling | | ----------- | --------------------------------------------------------------------------------- | ---------------------------------------- | | 1. Plan | Ratio, safe zones, second-by-second timeline (concepts) | | | 2. Board | One text-free still per mechanic at the delivery ratio, from the user's material | scenario-game-assets, scenario-image | | 3. Clips | Final-quality takes from the still, or cuts of the user's footage | scenario-video, scenario-seedance | | 4. Logic | Per take: timing, action crops, end frames, motion | | | 5. UI | Hook, HUD, hand, bursts, effects, end card (ui) | scenario-text-overlay | | 6. Assemble | One timeline at the exact length and canvas | scenario-video-assembly | | 7. Sound | A hit on every event, a separate music bed, mixed in assembly | scenario-audio | | 8. Check | Probe, levels, a 2 fps sheet, the reject list | |

Length and format

| Length | Setup or fail | Payoff | End card | | ------ | -------------------------- | -------------------------- | -------- | | 6 s | none, hook over payoff | 4.5 s | 1.5 s | | 10 s | 3.5 s | 4.5 s | 2 s | | 15 s | 5 s | 6 s | 4 s | | 20 s | 5 s | 6 s, then a 5 s escalation | 4 s | | 30 s | two rounds of fail and win | or three escalations | 4 s |

With footage, its own beats replace this split (inputs).

  • Compose each ratio natively: generate the board at the delivery canvas (1080x1920 for 9:16, 1080x1350 for 4:5, 1080x1080 for 1:1, 1920x1080 for 16:9). Never crop one ratio out of another.
  • Plan the board still in the placement's bands: background only under the platform UI, the HUD and hook just below it, every key action in the safe middle. Overlays with text and every tap target (a pin ring, a lever) stay in the safe zone, clear of TikTok's right rail: measure the targets on the board still before any take, and regenerate a board that misses.
  • Several placements: one board and one assembly run per ratio, from the same plan.

Make the viewer want to play

A board that changes correctly sells nothing. Plan every concept around its fantasy (power, cleverness, order, growth, rescue) and its Fun line in concepts:

  • The input reads within 2 s: the hand and the piece move together, and the game answers at once.
  • Every input gets a satisfying reaction in the motion itself: anticipation, contact, reaction. A piece wobbles on an edge, tips, then drops with a spin; a stack sways and settles. Write it beat by beat in the clip prompt.
  • Show a limit, then overcome it: a too-big object rattles across the rim until the hole grows.
  • What the fantasy rides on (a ball, a car, the hole) reads at phone size: about 4% of the frame width or more, with a trail when it moves fast. A growing subject follows a size curve planned per beat, and the camera pulls back so it stays about a third of the frame.
  • Escalate: each beat bigger or faster than the last, a near-fail, one clever move nobody expected, then the biggest moment near gameplay's end.
  • Never simplify the mechanic until the model cannot break it. Build a rich one in chained stages: one state still per step, each edited from the last, each take pinned from one state to the next with one visible move. Or script it from cut pieces (below).

Rules that carry the ad

  • The first frame holds the premise: board, hook line, stakes. A sound at 0.0, motion by 0.3 s, no logo intro.
  • Never let a board or video model draw text, numbers, gate values, buttons, or the hand into a still or a take: leave the slots blank and composite them.
  • One mechanic, escalating. Counters only climb, in 4 or 5 visible steps, each proportional to the event that causes it: one pickup never jumps a level from 30 to 99.
  • A fail tease is two takes from one still: the wrong move and its consequence, then the right move. Cut on a burst word.
  • One locked camera per take, at final quality. No push-in over a busy board: pipes, gates, and slots warp. Ask for a longer take and keep the clean first part.
  • The game logic must hold; players spot a cheat at once:
    • Video models ignore barriers: lava and coins flow through a closed pin. Design one visible move per path, with no pin, gate, or wall the take does not open.
    • Prefer straight drops and straight lanes. A pipe or a bend invites a shortcut outside it.
    • Every player move needs a reason on the board: a swipe reaches a collectible or dodges a hazard. Collectibles in one line make the swipe pointless.
    • Name every barrier's state in the prompt ("coins stay inside the glass") and what stays still.
    • A fixed end state is its own still, edited from the board with the same counts, pinned as the take's last frame. Pinning also locks the camera. Mask only what changes: a prop inside the mask can be redrawn. An edit can also change pixels outside it: paste only the masked region onto the source.
    • A precise move a model cannot do cleanly (a two-piece swap, a free drop) is built as layers from the still; the model animates only the consequence.
    • A barrier drawn locally over a generated take (a drawn line, a patch) gets a mask check inside it on every frame: bees sat inside a drawn dome for 74 frames.
    • A board whose every move must be exact (tile match, sort, merge, screw puzzle) is scripted whole: cut the pieces from the board still or the user's screenshot and animate them as layers. A video model adds only ambient motion behind them.
  • Assembly runs on model_scenario-compose-video, Scenario's one deterministic compositor, so its id is fixed (confirm with search).
  • Anything that moves on the UI layer is one transparent ProRes 4444 .mov, cropped to its motion box, never stepped image layers or WebM alpha (ui).
  • Sound: a hit on every visible event (tap, impact, pickup, counter step) on its frame, louder than the music. A video-to-audio pass on the silent cut adds incidental sound but misses events. Generate the bed separately, banning ambient pads, and shift it so its lift lands on the payoff.
  • Compose takes at most 50 layers (49 audio, so premix a dense run of hits into one stem) and has no limiter, so assembly runs in passes:
    • picture: clips and overlays, muted, into a silent master;
    • sound: the silent master as the one video layer under every audio layer, times to the millisecond;
    • loudness, only when the sound pass misses -16 to -14 LUFS or peaks above -1 dBTP: model_scenario-audio-extract with normalizeLoudness: true, then the silent master plus that one track. Scenario ships one tool for each of these jobs, so the ids are fixed.
  • End on the payoff, then an end card designed in the plan, like the hook, from this game's world: its level-complete screen with the label where "next level" sits, the next harder board frozen under "CAN YOU SOLVE IT?", or the hero carrying the label. Words from the game: SAVE HIM, DIG NOW, TRY LEVEL 2 (ui). Social feeds ban fake buttons, so the call to action is a label there; a button only on clickable ad-network cards.

Scripts

The agent runs these locally with Python 3.11+, Pillow 13, numpy 2, and ffmpeg. They render and plan; uploads and compose runs stay MCP calls. Each takes a JSON spec; --help lists its fields.

  • render_tracks.py: renders the hand, counters, rewards, bursts, and stars as cropped ProRes 4444 tracks, plus layers.json with compose-exact times and safe-zone warnings.
  • build_passes.py: simulate mixes the cue sheet locally and prints loudness, true peak, and each hit's margin; picture and sound write the two compose payloads.
  • check_master.py: on the downloaded master, checks canvas, length, loudness, true peak, dark frames, a 2 fps sheet, and each hit's onset (--sim reads them against the mix).
  • put_parts.py: PUTs a file to the signed S3 part URLs upload_asset returned and prints what upload_asset_complete needs.
  • check_take.py: the logic checks on each take before assembly; motion needs a locked camera.
  • make_patch.py: builds a clean-plate image layer that hides a static piece contradicting the count, and checks every take it covers.

Worked example: pin-pull rescue in chained stages, 15 seconds, TikTok 9:16

  1. Plan: 1080x1920, TikTok safe zone, HUD from y 280. Hook over the wrong pull: gold melts in the lava, FAIL at 2.5 s, rewind. Water pin at 3.8 s sets the lava into a stone ramp under a punch-in; gold pin at 5.8 s; cell pin at 8.3 s, the miner runs up the ramp into the cart. End card 11.2 to 15 s.
  2. Board: recommend an im

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars1.0k
CategoryMarketing
Updated29d ago
Forks129

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions