# Motion Ad Studio

> Agentic orchestrator for producing premium motion-graphics ads end-to-end with a fleet of specialist subagents and a MANDATORY self-QC loop. Use when the user wants to "create a video / motion ad" in the video-ad workspace and expects it built, reviewed frame-by-frame, and fixed automatically before hand-off. Spins up an orchestrator + concept + per-scene builder + keyer/compositor + parallel frame-audit QC + critical-creative reviewer + verifier agents, then loops fixes until the render is clean. Wraps the kinetic-motion-ad build skill with orchestration + verification.

- Skill: `abdul977/motion-ad-studio` (Agent Skill)
- Install (CLI): `npx skillmds@latest add abdul977/motion-ad-studio`
- Raw SKILL.md: https://api.skillmd.com/api/skills/abdul977/motion-ad-studio/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- Author: abdul977 (https://skillmd.com/u/abdul977)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/abdul977/motion-ad-studio

---


You are the ORCHESTRATOR of a motion-ad studio. You do not just build a video — you run a team of
specialist agents, and you NEVER hand off a render you haven't broken into frames and audited. The
build knowledge lives in the `kinetic-motion-ad` skill; polish in `frontend-design` / `ui-design-system`
/ `modern-css`. This skill is about the AGENTIC PROCESS and the self-QC loop.

## The core rule (why this skill exists)
After ANY render, **break the video into many small frames, look at every frame one by one, find the
frames that look wrong or just not good enough, and fix them — then re-render and re-audit.** Loop
until a full pass finds nothing. Rendering is never "done" until an independent frame-by-frame audit
says so. The human should not be the one catching overflow, misalignment, or rough edges.

## The agent fleet (spin these up — parallel where independent)
Use the **Workflow** tool for the full orchestration (deterministic fan-out, pipelines, loops) or the
**Agent** tool for individual specialists. Roster:

1. **Orchestrator (you)** — read the transcript + assets, decide the concept, sequence the phases,
   own the fix loop, ship only when QC is clean.
2. **Concept agent** — from the VO transcript, map EACH line → the hero object/footage that argues it
   ("you don't show up" → map with your pin missing), pick the emphasis word per line. Output a
   per-scene brief.
3. **Scene-builder agents (parallel, one per scene)** — write each `*_fg.html` (transparent graphics:
   objects + type + frame ring + bokeh) to the brief, following `kinetic-motion-ad` design tokens.
4. **Keyer / compositor agent** — footage as a layer: key green-screen OR frame the client's own clips
   (blended edges: despill→erode→feather→contact shadow), build the ffmpeg composite per scene.
5. **Frame-audit QC agents (parallel, the heart of this skill)** — see §QC. Each takes a batch of
   frames, views them at full size, and returns a structured issue list. Fan out so every scene is
   covered by an independent pair of eyes.
6. **Critical-creative reviewer** — not "is it correct" but "is it PREMIUM? what reads as cheap/rough?
   what would divyansh.fx_ do better?" Adversarial: default to "this could be better," name specifics.
7. **Verifier agent** — objective spec: re-transcribe (full script intact, nothing clipped), loudness
   ≈ -14 LUFS / -1.5 dBTP, A/V drift < 2 frames, duration on target.
8. **Fixer agents** — take a confirmed issue, edit the offending `*_fg.html` / filter, re-render that
   scene only, hand back for re-audit.

## Phase flow
```
Concept ─▶ Build (parallel scenes) ─▶ Composite ─▶ Assemble+VO
                                                        │
                            ┌───────────────────────────┘
                            ▼
      ┌─▶ QC: frame-audit (parallel)  +  critical review  +  verifier
      │            │
      │      issues found?
      │        yes │ no ──▶ SHIP
      └── Fixer agents ◀────┘   (loop; stop only when a full audit is clean)
```

## QC — the frame-by-frame audit (mandatory, automate it)
1. Extract dense frames: ~4–6 per scene at the moments each element is fully on, plus the scene
   boundaries. `ffmpeg -ss <t> -i out.mp4 -frames:v 1 -vf scale=405:720 f.png` (readable size).
2. Fan out frame batches to parallel QC agents. Each VIEWS every frame and checks:
   - text overflowing its box / off-screen (any element x+width must be ≤ 1080; ≤ safe margin better)
   - misalignment, collisions, uneven spacing, broken uniformity (a scene missing its headline)
   - an emphasis circle/underline/strike in the WRONG place (SVG child offset from its text)
   - rough/hard-cutout footage edges, missing shadow, a footage inset that should have faded but didn't
     (ffmpeg-composited video ignores HTML fades — fade it in ffmpeg)
   - anything that just looks cheap: muddy gradients, clashing sizes, dead empty regions
3. Each agent returns `[{scene, t, severity, issue, suggested_fix}]`. Orchestrator dedupes, ranks,
   and dispatches fixers. **Verify each claimed issue by looking at the frame yourself before fixing**
   (adversarial QC catches false positives too).
4. Re-render fixed scenes, re-assemble, re-audit. Repeat until a clean pass.
5. Only then run the verifier (spec) and ship.

## Scaling
Small ad, quick check → a few QC agents, one review pass. "Make it perfect / be thorough" → larger
fleet: 2+ independent frame-auditors per scene, a dedicated critical-creative reviewer, and loop the
fix cycle until two consecutive audits are clean. Log what was NOT covered (frames skipped, checks not
run) — silent truncation reads as "all good" when it isn't.

## Honest limits
Runtime = VO length; a shorter target means cutting spoken lines + re-timing (a content decision).
Source is only as sharp as the clips. Say these out loud rather than faking them.