launch-autopilot

89 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

• launch-autopilot/SKILL.md9.1 KBfc56602e4430upstream ↗

  ---
  name: launch-autopilot
  description: >
    End-to-end product marketing from the product's own files: reads the README, docs, changelog,
    code and screenshots, writes the positioning context, a day-by-day launch and growth strategy,
    then produces the actual assets (social posts, carousels, images, OG cards, posters, short videos)
    and fills a dated content queue months ahead that can be refilled and re-planned when a new
    feature ships. Use this whenever someone has a product, app, SaaS, library, game or side project
    and wants to launch it, market it, "start publishing", "get users", plan posts, make a content
    calendar, create launch videos or posters, automate their social media, run marketing on a
    schedule, or announce a new feature/release — even if they never say "marketing" or "launch".
    Also triggers on /launch-autopilot and its subcommands (setup, strategy, assets, video, poster,
    queue, today, new-feature, refill, review, audit, export, schedule).
  license: MIT (includes MIT-licensed prompts from coreyhaines31/marketingskills; see references/marketingskills/LICENSE)
  ---
  
  # Launch Autopilot
  
  You are a senior product marketer and producer. You turn a product's real files into a launch
  strategy, a calendar with something to do every day, the finished assets for each post, and a
  queue that keeps itself full. Two things make this worth more than a pile of posts:
  
  1. **Every claim traces to the product.** Features, numbers and quotes come from the README, docs,
     code, changelog or the user. Invented stats, fake testimonials and hallucinated UI are how
     launches get embarrassed in public comments, so never produce them. Screenshots must be real.
  2. **The plan survives change.** New features, price changes and quiet weeks are the normal case.
     The queue (`scripts/contentq.py`) lets dated launch posts claim their slot while evergreen posts
     shift forward, and `audit` catches queued posts a change made wrong.
  
  `<skill>` below means this skill's directory. Scripts need Python 3, Playwright (Chromium) and
  ffmpeg; check with `python3 -c "import playwright"` and `which ffmpeg`, install if missing
  (`pip install playwright segno && playwright install chromium`).
  
  ## Files this skill keeps (in the product's repo, or the working folder)
  
  | Path | What |
  |---|---|
  | `.agents/product-marketing.md` | Positioning context — the exact format of the vendored `product-marketing` skill, so all coreyhaines31 skills can read it too |
  | `marketing/brand.json` | Colors, fonts, logo, URL (schema: `<skill>/assets/templates/_brand.example.json`) |
  | `marketing/strategy.md` | Goals, ICP, channels and why, phases, KPIs |
  | `marketing/calendar.md` | Day-by-day plan: every task, not only posts |
  | `marketing/queue.json` | Every planned post with copy, assets, UTM link, status |
  | `marketing/assets/<post-id>/` | Rendered PNG/PDF/MP4 plus their HTML/storyboard sources |
  | `marketing/state.json` | Last processed commit/changelog version, last refill date |
  
  If any already exist, read them first and continue from them. Never overwrite the queue or context
  wholesale; edit them.
  
  ## Commands
  
  Users can type these as `/launch-autopilot <command>` or just say what they want. With no command,
  run **go**.
  
  | Command | Does | Details |
  |---|---|---|
  | `go` | setup → strategy → first 2 weeks of assets → queue → offer `schedule` | all three references |
  | `setup` | Read product files, write context + brand.json | Step 1 below |
  | `strategy [30\|60\|90] [launch=YYYY-MM-DD]` | Strategy + day-by-day calendar + queue skeleton | `references/strategy.md` |
  | `assets [week N\|P0007\|type]` | Write copy and render assets for queued posts | `references/assets.md` |
  | `video <topic\|post-id>` | Storyboard → MP4 (reel/short/demo/launch trailer) | `references/assets.md` §Video |
  | `poster [size] [count]` | Print posters (PDF) — delegates to `/make-poster` if installed | `references/assets.md` §Posters |
  | `queue` / `today` / `week` | Status and runway / what to post today / this week, with files | `references/autopilot.md` |
  | `new-feature [ref\|description]` | Read what shipped, tier it, inject a mini-launch, re-plan | `references/autopilot.md` §New feature |
  | `refill [days]` | Top the queue up to N days of runway from pillars + repurposing | `references/autopilot.md` §Refill |
  | `review` | Weekly performance review → learnings in the context doc | `references/autopilot.md` §Review |
  | `audit` | Find queued posts and pages a change made wrong | `references/autopilot.md` §Audit |
  | `export [csv\|ics]` | CSV for Buffer/Later/Hootsuite bulk upload, ICS reminders for your calendar | `contentq.py export` |
  | `schedule` | Create recurring scheduled tasks (daily brief, weekly refill+review, release watch) | `references/autopilot.md` §Schedule |
  
  ## Step 1 — Setup: read the product before asking anything
  
  Read, in roughly this order, and stop when you have enough: README and docs (`docs/`, `*.md`),
  how-to/usage guides, `CHANGELOG*`/release notes, `package.json`/`pyproject.toml`/app manifests
  (name, description, keywords), landing page and in-app copy (routes, pages, i18n strings),
  pricing logic, `git log --oneline -50`, and existing screenshots, logos and icons (`public/`,
  `assets/`, store listings). For brand: CSS variables, Tailwind config, theme files, font imports.
  If the user only gave a URL or a description, work from that and say what you couldn't verify.
  
  Then follow `references/marketingskills/product-marketing/GUIDE.md` in its **auto-draft** mode to
  write `.agents/product-marketing.md` (its template, versioning and changelog rules apply). Add a
  **Feature inventory** section the original lacks — one row per user-facing feature:
  `feature | what the user can now do | proof (file/doc) | screenshot path or "needs capture"`.
  This inventory is what posts, videos and the new-feature flow draw from.
  
  Write `marketing/brand.json`. If there is no brand, propose one (2 colors + 1 font pair) and say so.
  
  Capture real screenshots when the product runs locally or has a public URL: start it if the README
  says how, then use Playwright to screenshot the 3–6 screens that show the core job, at 2x, into
  `marketing/assets/screens/`. If you can't run it, list the shots you need from the user.
  
  Show the user a 5-line summary (one-liner, ICP, top 3 differentiators, proof you found, gaps) and
  ask only what the files can't answer — at most one AskUserQuestion round:
  - launch date (or "already live"), primary goal and conversion action
  - hours per week they can spend, and whether they'll be on camera
  - channels they already have (audience size), and languages to publish in
  - paid tools/budget (scheduler, video avatar, ads) — default: none
  
  If nobody answers, assume: live now, goal = signups, 3 h/week, no camera, X + LinkedIn + one
  community, English, no paid tools; state the assumptions at the top of `strategy.md`.
  
  ## Steps 2–4
  
  - **Strategy & calendar:** `references/strategy.md`.
  - **Assets:** `references/assets.md`. Produce the first 14 days fully; later weeks get copy and
    briefs, rendered by `refill`/scheduled runs so the assets stay current with the product.
  - **Queue & automation:** `references/autopilot.md`.
  
  ## Copy rules (apply to every word you write)
  
  - Use the context doc's customer language and voice. One idea per post; lead with what the user
    can now do, then the proof.
  - Follow the "No AI tells" lists in `references/marketingskills/social/GUIDE.md` and
    `references/marketingskills/copywriting/references/ai-tells.md`. If the `humanizer` skill is
    installed, run drafts through it before they go in the queue.
  - Respect platform limits (`references/marketingskills/social/references/platform-limits.md`).
  - Disclose: AI-generated avatars/voices, paid partnerships (#ad), affiliate links. No fake
    reviews, sockpuppets, engagement pods or upvote rings — they violate platform rules (Product
    Hunt and Reddit ban for it) and get found out.
  - Every asset gets alt text; every video gets burned-in captions.
  
  ## Publishing boundary
  
  The skill drafts, renders, schedules in the queue and exports. Posting to real accounts happens
  only after the user approves specific posts (`contentq.py set --status approved`) and only
  through a scheduler they connected (check for Buffer, Typefully, Hootsuite or similar connectors;
  offer to connect one) or by them uploading the CSV. Never post, send email, submit directories or
  spend money on your own initiative, including in scheduled runs.
  
  ## Finish
  
  End each command with: what was produced (files), what needs the user (approvals, screenshots,
  recording a face-cam clip), and the next date something is due. Keep it short — the calendar and
  queue hold the detail.
  
  ## Where the vendored prompts are
  
  `references/marketingskills/<skill>/GUIDE.md` (MIT, © Corey Haines, commit in `SOURCE_COMMIT`):
  product-marketing, launch (ORB, SLC readiness gate, 5 phases, Product Hunt, shipped-changes),
  social (pillars, hooks, repurposing, short-form video, platform refs, carousels, X algorithm),
  copywriting, content-strategy, emails, directory-submissions, community-marketing,
  public-relations, marketing-psychology, image, video, ad-creative, aso (mobile apps),
  marketing-loops (loop anatomy, guardrails, state). Read the one a step names; don't load them all.
  

• launch-autopilot/scripts/contentq.py8.4 KBf19fa4dc6336upstream ↗

  #!/usr/bin/env python3
  """Content queue for launch-autopilot. One JSON file holds every planned post.
  
    contentq.py init     --file Q --product NAME [--tz Europe/Bucharest]
    contentq.py add      --file Q --posts posts.json         # append (array of posts)
    contentq.py inject   --file Q --posts posts.json         # fixed-date posts win; evergreen slots they collide with move to the next free day
    contentq.py due      --file Q [--date YYYY-MM-DD] [--days 1]
    contentq.py status   --file Q [--date YYYY-MM-DD]        # counts + runway (days of approved/draft content left)
    contentq.py set      --file Q --ids P0001,P0002 --status approved
    contentq.py flag     --file Q --grep "old text"          # future posts containing text -> needs_review (claim drift)
    contentq.py export   --file Q --csv out.csv | --ics out.ics
    contentq.py selftest
  
  Post fields: date, time, platform, format, pillar, kind (launch|feature|evergreen|fixed),
  title, copy, assets[], alt, cta_url, status (draft|approved|scheduled|posted|needs_review|skipped), source, notes.
  """
  import argparse, csv, json, os, sys, tempfile
  from datetime import date, datetime, timedelta, timezone
  from urllib.parse import urlencode, urlparse, parse_qsl, urlunparse
  
  LIVE = {"draft", "approved", "scheduled", "needs_review"}  # still going out
  
  
  def load(p):
      with open(p) as f:
          return json.load(f)
  
  
  def save(p, q):
      q["posts"].sort(key=lambda x: (x["date"], x.get("time", ""), x["id"]))
      tmp = p + ".tmp"
      with open(tmp, "w") as f:
          json.dump(q, f, indent=2, ensure_ascii=False)
      os.replace(tmp, p)  # atomic: a crash never leaves a half-written queue
  
  
  def utm(url, post):
      if not url or "utm_source" in url:
          return url
      u = urlparse(url)
      qs = dict(parse_qsl(u.query))
      qs.update(utm_source=post["platform"], utm_medium="social",
                utm_campaign=post.get("source") or post.get("kind", "evergreen"), utm_content=post["id"])
      return urlunparse(u._replace(query=urlencode(qs)))
  
  
  def normalize(q, posts):
      n = max([int(p["id"][1:]) for p in q["posts"]] or [0])
      out = []
      for p in posts:
          for k in ("date", "platform"):
              if k not in p:
                  sys.exit(f"post missing '{k}': {p}")
          date.fromisoformat(p["date"])  # validate
          if not p.get("id"):
              n += 1
              p["id"] = f"P{n:04d}"
          p.setdefault("kind", "evergreen")
          p.setdefault("status", "draft")
          p.setdefault("assets", [])
          p["cta_url"] = utm(p.get("cta_url", ""), p)
          out.append(p)
      return out
  
  
  def taken(q):
      return {(p["date"], p["platform"]) for p in q["posts"] if p["status"] in LIVE}
  
  
  def inject(q, new):
      """Fixed-date posts claim their slot; a colliding evergreen post moves to the next free day
      on its platform (cascading). Launch/feature/fixed posts never move."""
      for p in new:
          slot = (p["date"], p["platform"])
          clash = [o for o in q["posts"] if (o["date"], o["platform"]) == slot and o["status"] in LIVE]
          q["posts"].append(p)
          for o in clash:
              if o.get("kind", "evergreen") != "evergreen":
                  continue  # two dated posts on one slot is allowed; user asked for both
              d = date.fromisoformat(o["date"])
              busy = taken(q) - {(o["date"], o["platform"])} | {slot}
              while (d.isoformat(), o["platform"]) in busy:
                  d += timedelta(days=1)
              o["notes"] = (o.get("notes", "") + f" moved from {o['date']} for {p['id']}").strip()
              o["date"] = d.isoformat()
  
  
  def runway(q, today):
      live = [p["date"] for p in q["posts"] if p["status"] in LIVE and p["date"] >= today]
      return (date.fromisoformat(max(live)) - date.fromisoformat(today)).days if live else 0
  
  
  def export_ics(q, path):
      lines = ["BEGIN:VCALENDAR", "VERSION:2.0", "PRODID:-//launch-autopilot//EN"]
      for p in q["posts"]:
          if p["status"] not in LIVE:
              continue
          t = (p.get("time") or "09:00").replace(":", "")
          start = p["date"].replace("-", "") + "T" + t + "00"
          desc = (p.get("copy", "") + "\\n" + p.get("cta_url", "")).replace("\n", "\\n").replace(",", "\\,")
          lines += ["BEGIN:VEVENT", f"UID:{p['id']}@launch-autopilot", f"DTSTAMP:{datetime.now(timezone.utc):%Y%m%dT%H%M%SZ}",
                    f"DTSTART;TZID={q.get('timezone', 'UTC')}:{start}", "DURATION:PT15M",
                    f"SUMMARY:[{p['platform']}] {p.get('title', p['id'])}", f"DESCRIPTION:{desc}", "END:VEVENT"]
      lines.append("END:VCALENDAR")
      with open(path, "w") as f:
          f.write("\r\n".join(lines) + "\r\n")
  
  
  def main(argv=None):
      a = argparse.ArgumentParser()
      a.add_argument("cmd")
      a.add_argument("--file", default="marketing/queue.json")
      a.add_argument("--product"); a.add_argument("--tz", default="UTC")
      a.add_argument("--posts"); a.add_argument("--date", default=date.today().isoformat())
      a.add_argument("--days", type=int, default=1)
      a.add_argument("--ids"); a.add_argument("--status"); a.add_argument("--grep")
      a.add_argument("--csv"); a.add_argument("--ics")
      o = a.parse_args(argv)
  
      if o.cmd == "selftest":
          return selftest()
      if o.cmd == "init":
          if os.path.exists(o.file):
              sys.exit(f"{o.file} exists; refusing to overwrite")
          os.makedirs(os.path.dirname(o.file) or ".", exist_ok=True)
          save(o.file, {"product": o.product, "timezone": o.tz, "posts": []})
          return print(f"created {o.file}")
  
      q = load(o.file)
      if o.cmd in ("add", "inject"):
          new = normalize(q, load(o.posts))
          q["posts"].extend(new) if o.cmd == "add" else inject(q, new)
          save(o.file, q)
          print(f"{o.cmd}: {len(new)} posts -> {', '.join(p['id'] for p in new)}")
      elif o.cmd == "due":
          end = (date.fromisoformat(o.date) + timedelta(days=o.days - 1)).isoformat()
          for p in q["posts"]:
              if o.date <= p["date"] <= end and p["status"] in LIVE:
                  print(json.dumps(p, ensure_ascii=False))
      elif o.cmd == "status":
          counts = {}
          for p in q["posts"]:
              counts[p["status"]] = counts.get(p["status"], 0) + 1
          r = runway(q, o.date)
          print(json.dumps({"total": len(q["posts"]), "by_status": counts, "runway_days": r,
                            "refill_needed": r < 14}, indent=2))
      elif o.cmd == "set":
          ids = set(o.ids.split(","))
          for p in q["posts"]:
              if p["id"] in ids:
                  p["status"] = o.status
          save(o.file, q)
      elif o.cmd == "flag":
          hit = [p for p in q["posts"] if p["date"] >= o.date and p["status"] in LIVE
                 and o.grep.lower() in json.dumps(p, ensure_ascii=False).lower()]
          for p in hit:
              p["status"] = "needs_review"
          save(o.file, q)
          print(f"flagged {len(hit)}: {', '.join(p['id'] for p in hit)}")
      elif o.cmd == "export":
          if o.csv:
              cols = ["id", "date", "time", "platform", "format", "title", "copy", "cta_url", "assets", "alt", "status"]
              with open(o.csv, "w", newline="") as f:
                  w = csv.writer(f); w.writerow(cols)
                  for p in q["posts"]:
                      if p["status"] in LIVE:
                          w.writerow([";".join(p[c]) if c == "assets" else p.get(c, "") for c in cols])
          if o.ics:
              export_ics(q, o.ics)
          print("exported")
      else:
          sys.exit(f"unknown command {o.cmd}")
  
  
  def selftest():
      d = tempfile.mkdtemp(); f = os.path.join(d, "q.json"); pf = os.path.join(d, "p.json")
      main(["init", "--file", f, "--product", "T"])
      json.dump([{"date": "2030-01-01", "platform": "x", "cta_url": "https://t.co/a"},
                 {"date": "2030-01-02", "platform": "x"}], open(pf, "w"))
      main(["add", "--file", f, "--posts", pf])
      json.dump([{"date": "2030-01-01", "platform": "x", "kind": "feature", "copy": "new export"}], open(pf, "w"))
      main(["inject", "--file", f, "--posts", pf])
      q = load(f)
      by = {p["id"]: p for p in q["posts"]}
      assert by["P0003"]["date"] == "2030-01-01"
      assert by["P0001"]["date"] == "2030-01-03", by["P0001"]  # skipped the taken 01-02
      assert "utm_content=P0001" in by["P0001"]["cta_url"]
      assert runway(q, "2030-01-01") == 2
      main(["flag", "--file", f, "--grep", "NEW EXPORT", "--date", "2030-01-01"])
      assert load(f)["posts"][0]["status"] == "needs_review"
      main(["export", "--file", f, "--ics", os.path.join(d, "q.ics"), "--csv", os.path.join(d, "q.csv")])
      print("selftest ok")
  
  
  if __name__ == "__main__":
      main()
  

• launch-autopilot/scripts/render.py3.5 KB6b6b39b540f4upstream ↗

  #!/usr/bin/env python3
  """Render HTML to PNG or PDF with headless Chromium (Playwright).
  
    render.py in.html out.png [--data data.json ...] [--size 1080x1350]
    render.py in.html out.pdf                      # print PDF at the page's @page size
    render.py --batch SRC_DIR OUT_DIR [--data ...] # every *.html; size from <meta name="size">
  
  {{key}} placeholders are filled from the --data JSON files (later files win), so
  brand.json + a per-post JSON drive one template. {{qr}} becomes an inline QR SVG of
  data["qr_url"] (needs: pip install segno). Unfilled placeholders fail the render,
  so no "{{headline}}" ever ships.
  """
  import argparse, json, os, re, sys
  from pathlib import Path
  
  
  def fill(html, data):
      if "{{qr}}" in html and data.get("qr_url"):
          import segno, io
          buf = io.BytesIO()
          segno.make(data["qr_url"], error="m").save(buf, kind="svg", border=4, xmldecl=False, svgns=True, omitsize=True)
          data = {**data, "qr": buf.getvalue().decode()}
      out = re.sub(r"\{\{(\w+)\}\}", lambda m: str(data.get(m.group(1), m.group(0))), html)
      left = set(re.findall(r"\{\{(\w+)\}\}", out))
      if left:
          sys.exit(f"unfilled placeholders: {sorted(left)}")
      return out
  
  
  def size_of(html, override):
      m = re.search(r'<meta name="size" content="(\d+x\d+)"', html)
      w, h = map(int, (override or (m and m.group(1)) or "1080x1350").split("x"))
      return w, h
  
  
  def settle(page):
      """Let finite CSS animations finish so stills show the end state (cap 5s)."""
      page.evaluate("Promise.race([Promise.all(document.getAnimations().map(a=>a.finished)),new Promise(r=>setTimeout(r,5000))])")
  
  
  def render(page, src, out, data, size=None):
      html = fill(Path(src).read_text(), data)
      tmp = Path(src).with_suffix(".rendered.html")  # same dir so relative asset paths resolve
      tmp.write_text(html)
      try:
          w, h = size_of(html, size)
          page.set_viewport_size({"width": w, "height": h})
          page.goto(tmp.resolve().as_uri(), wait_until="networkidle")
          page.evaluate("document.fonts.ready")
          settle(page)
          Path(out).parent.mkdir(parents=True, exist_ok=True)
          if out.endswith(".pdf"):
              page.pdf(path=out, prefer_css_page_size=True, print_background=True)
          else:
              page.screenshot(path=out, clip={"x": 0, "y": 0, "width": w, "height": h})
          # overflow check: content wider/taller than the canvas means clipped text
          sw, sh = page.evaluate("[document.documentElement.scrollWidth, document.documentElement.scrollHeight]")
          if not out.endswith(".pdf") and (sw > w or sh > h):
              print(f"WARNING {out}: content {sw}x{sh} overflows canvas {w}x{h}", file=sys.stderr)
      finally:
          tmp.unlink(missing_ok=True)
      print(out)
  
  
  def main():
      a = argparse.ArgumentParser()
      a.add_argument("src"); a.add_argument("out")
      a.add_argument("--data", action="append", default=[])
      a.add_argument("--size"); a.add_argument("--batch", action="store_true")
      o = a.parse_args()
      data = {}
      for d in o.data:
          data.update(json.loads(Path(d).read_text()))
      from playwright.sync_api import sync_playwright
      with sync_playwright() as p:
          b = p.chromium.launch()
          page = b.new_page(device_scale_factor=1)
          if o.batch:
              for f in sorted(Path(o.src).glob("*.html")):
                  if not f.name.endswith(".rendered.html"):
                      render(page, f, os.path.join(o.out, f.stem + ".png"), data, o.size)
          else:
              render(page, o.src, o.out, data, o.size)
          b.close()
  
  
  if __name__ == "__main__":
      main()
  

• launch-autopilot/scripts/video.py6.1 KBc7539943a7b1upstream ↗

  #!/usr/bin/env python3
  """Storyboard JSON -> MP4 (H.264, captions burned in, optional music). Needs Playwright + ffmpeg.
  
    video.py storyboard.json            # writes storyboard["out"] (default video.mp4 next to it)
    video.py --selftest
  
  storyboard.json:
  {
    "size": "1080x1920", "fps": 30, "out": "launch-reel.mp4",
    "data": ["../../brand.json"],                 # placeholder values for HTML scenes
    "audio": "music.mp3",                          # optional; trimmed + faded to video length
    "scenes": [
      {"html": "scene-hook.html", "duration": 2.5, "animate": true, "data": {"headline": "..."}},
      {"html": "scene-card.html", "duration": 3},                 # static, gets a slow push-in
      {"image": "screens/dashboard.png", "duration": 3, "caption": "Export in one click"}
    ]
  }
  animate=true records the page live, so CSS/JS animations play. Static scenes and images get a
  slow zoom so nothing sits frozen. Paths are relative to the storyboard file.
  """
  import json, os, subprocess, sys, tempfile
  from pathlib import Path
  
  sys.path.insert(0, str(Path(__file__).parent))
  from render import fill, settle  # noqa: E402
  
  CAPTION_HTML = """<!doctype html><html><head><meta charset="utf-8"><style>
  html,body{margin:0;width:{{w}}px;height:{{h}}px;background:{{bg}};overflow:hidden;font-family:{{font}},system-ui,sans-serif}
  img{position:absolute;inset:6% 5% 30% 5%;width:90%;height:64%;object-fit:contain;border-radius:24px}
  .cap{position:absolute;left:6%;right:6%;top:72%;text-align:center;color:#fff;font-weight:800;
  font-size:{{fs}}px;line-height:1.15;-webkit-text-stroke:2px #000;paint-order:stroke fill;text-shadow:0 4px 12px #000a}
  </style></head><body><img src="{{src}}"><div class="cap">{{caption}}</div></body></html>"""
  
  
  def ff(*args):
      subprocess.run(["ffmpeg", "-y", "-loglevel", "error", *args], check=True)
  
  
  def still_clip(png, out, dur, w, h, fps):
      frames = int(dur * fps)
      vf = (f"scale={w*2}:{h*2},zoompan=z='min(zoom+0.0006,1.05)':d={frames}:s={w}x{h}:fps={fps},"
            f"fade=t=in:d=0.25,fade=t=out:st={dur-0.25}:d=0.25,format=yuv420p")
      ff("-loop", "1", "-i", png, "-t", str(dur), "-vf", vf, "-r", str(fps), "-c:v", "libx264", out)
  
  
  def build(sb_path):
      sb_path = Path(sb_path).resolve(); base = sb_path.parent
      sb = json.loads(sb_path.read_text())
      w, h = map(int, sb.get("size", "1080x1920").split("x")); fps = sb.get("fps", 30)
      data = {}
      for d in sb.get("data", []):
          data.update(json.loads((base / d).read_text()))
      work = Path(tempfile.mkdtemp()); clips = []
      from playwright.sync_api import sync_playwright
      with sync_playwright() as p:
          b = p.chromium.launch()
          for i, s in enumerate(sb["scenes"]):
              dur = float(s.get("duration", 3)); clip = str(work / f"c{i:02d}.mp4"); vals = {**data, **s.get("data", {})}
              if "image" in s:
                  html = fill(CAPTION_HTML, {"w": w, "h": h, "bg": vals.get("bg", "#111"), "font": vals.get("font_body", "Inter"),
                                             "fs": int(w * 0.065), "src": (base / s["image"]).resolve().as_uri(),
                                             "caption": s.get("caption", "")})
                  src = work / f"s{i}.html"; src.write_text(html)
              else:
                  src = work / f"s{i}.html"
                  src.write_text(fill((base / s["html"]).read_text(), vals).replace(
                      "<head>", f'<head><base href="{(base / s["html"]).parent.as_uri()}/">', 1))
              if s.get("animate"):
                  ctx = b.new_context(viewport={"width": w, "height": h}, record_video_dir=str(work),
                                      record_video_size={"width": w, "height": h})
                  pg = ctx.new_page(); pg.goto(src.as_uri(), wait_until="load"); pg.wait_for_timeout(int(dur * 1000) + 300)
                  webm = pg.video.path(); ctx.close()
                  ff("-i", webm, "-ss", "0.15", "-t", str(dur), "-vf", f"fps={fps},scale={w}:{h},format=yuv420p",
                     "-c:v", "libx264", clip)
              else:
                  pg = b.new_page(viewport={"width": w, "height": h}); pg.goto(src.as_uri(), wait_until="networkidle"); settle(pg)
                  png = str(work / f"s{i}.png"); pg.screenshot(path=png); pg.close()
                  still_clip(png, clip, dur, w, h, fps)
              clips.append(clip)
          b.close()
      lst = work / "list.txt"; lst.write_text("".join(f"file '{c}'\n" for c in clips))
      out = str(base / sb.get("out", "video.mp4")); silent = str(work / "silent.mp4")
      ff("-f", "concat", "-safe", "0", "-i", str(lst), "-c", "copy", silent)
      if sb.get("audio"):
          total = sum(float(s.get("duration", 3)) for s in sb["scenes"])
          ff("-i", silent, "-i", str(base / sb["audio"]), "-map", "0:v", "-map", "1:a", "-c:v", "copy", "-c:a", "aac",
             "-af", f"afade=t=out:st={max(total-1, 0)}:d=1", "-shortest", out)
      else:
          os.replace(silent, out)
      print(out)
      return out
  
  
  def selftest():
      d = Path(tempfile.mkdtemp())
      from PIL import Image
      Image.new("RGB", (800, 500), "#3b82f6").save(d / "shot.png")
      (d / "a.html").write_text('<!doctype html><html><head><style>body{margin:0;background:{{bg}};color:#fff;'
                                'font:800 90px sans-serif;display:grid;place-items:center;height:100vh}'
                                'h1{animation:u 1s ease-out}@keyframes u{from{transform:translateY(200px);opacity:0}}'
                                '</style></head><body><h1>{{headline}}</h1></body></html>')
      (d / "sb.json").write_text(json.dumps({"size": "540x960", "fps": 24, "out": "t.mp4", "scenes": [
          {"html": "a.html", "duration": 1.5, "animate": True, "data": {"bg": "#111", "headline": "Hi"}},
          {"html": "a.html", "duration": 1, "data": {"bg": "#222", "headline": "Still"}},
          {"image": "shot.png", "duration": 1, "caption": "Real screenshot"}]}))
      out = build(d / "sb.json")
      dur = float(subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", out],
                                 capture_output=True, text=True).stdout)
      assert abs(dur - 3.5) < 0.3, dur
      print(f"selftest ok ({dur:.2f}s)")
  
  
  if __name__ == "__main__":
      selftest() if sys.argv[1:] == ["--selftest"] else build(sys.argv[1])
  

• launch-autopilot/references/assets.md5.3 KBa58de8c3e1a3upstream ↗

  # Asset factory
  
  For each post in scope (`contentq.py due --date <start> --days 14` or the IDs asked for): write
  the copy, make the asset, update the post in the queue (`copy`, `assets`, `alt`, `cta_url`,
  `status: draft`). Work in `marketing/assets/<post-id>/`. Batch similar assets with one small
  script and one data file per post rather than hand-editing many HTML files.
  
  Pick the format from the post's `format`; if unset, choose what the platform rewards
  (`marketingskills/social/references/platforms.md`): carousels on LinkedIn/Instagram, short video
  on TikTok/Reels/Shorts, image or 20–40 s clip on X, screenshots on Product Hunt/directories.
  
  ## Copy
  
  Hook formulas and post templates: `marketingskills/social/GUIDE.md` and
  `social/references/post-templates.md`. Carousels: pick a framework from
  `social/references/carousel-frameworks.md` first. Long-form (blog/launch post/landing):
  `marketingskills/copywriting/GUIDE.md`. Each post: hook from a real detail → one point → proof →
  one CTA. Put links where the platform prefers (LinkedIn: first comment).
  
  ## Images, carousels, OG cards, stories
  
  Templates in `<skill>/assets/templates/` (sizes in each file's `<meta name="size">`):
  `social-post.html` 1080×1350 · `carousel-slide.html` 1080×1350 · `story-scene.html` 1080×1920
  (also the default video scene) · `og-image.html` 1200×630 · `poster.html` A3.
  
  ```bash
  cp <skill>/assets/templates/social-post.html marketing/assets/P0007/
  # P0007/data.json: {"eyebrow":"…","headline":"…","sub":"…","image":"../screens/export.png","alt":"…"}
  python3 <skill>/scripts/render.py marketing/assets/P0007/social-post.html marketing/assets/P0007/post.png \
    --data marketing/brand.json --data marketing/assets/P0007/data.json
  ```
  
  Unfilled `{{placeholders}}` stop the render; pass `""` for optional ones (empty images hide).
  Templates are starting points — change layout freely, keep brand tokens. For other sizes, change
  the meta size and canvas CSS together (specs: `marketingskills/image/GUIDE.md`).
  
  **Look at every render** (Read the PNG): text clipped or overflowing (render.py also warns),
  contrast, headline readable at phone size (zoom out), nothing important in 9:16 safe zones, real
  UI only, no leftover placeholder text. Fix and re-render, up to 3 rounds.
  
  Generated imagery (backgrounds, lifestyle scenes): use an image model only if the user has one
  connected; prompting guide in `marketingskills/image/references/ai-image-prompting.md`. Never
  generate the product's UI. If Canva is connected, `canva:bulk-create` can fill a brand template
  from the queue CSV and `canva:resize-for-social-media` makes platform variants.
  
  ## Video
  
  Default pipeline (no paid tools): HTML scenes + real screenshots → `scripts/video.py`.
  
  1. Script from `marketingskills/social/references/short-form-video.md`: visual + verbal + text
     hook in the first second; problem → product doing the job → result → CTA. 15–30 s for
     Reels/TikTok, 30–60 s for Shorts/LinkedIn, 60–90 s for a launch trailer.
  2. Storyboard — one scene per beat, 1.5–4 s each:
  
  ```json
  {"size": "1080x1920", "fps": 30, "out": "reel.mp4", "data": ["../../brand.json"],
   "audio": "",
   "scenes": [
    {"html": "story-scene.html", "duration": 2.5, "animate": true,
     "data": {"kicker": "Stop retyping notes", "headline": "Meeting audio → tasks", "sub": ""}},
    {"image": "../screens/upload.png",  "duration": 3, "caption": "Drop in a recording"},
    {"image": "../screens/tasks.png",   "duration": 3, "caption": "Owners and dates, filled in"},
    {"html": "story-scene.html", "duration": 3, "animate": true,
     "data": {"kicker": "Free to try", "headline": "acmenotes.app", "sub": "Link in bio"}}
   ]}
  ```
  
  Remove the `"audio"` key or set a licensed track the user supplied (no copyrighted music).
  `python3 <skill>/scripts/video.py marketing/assets/P0012/storyboard.json`. Then pull 3 frames
  (`ffmpeg -i reel.mp4 -vf "select='not(mod(n\,45))',scale=270:-1,tile=4x1" -frames:v 1 strip.png`)
  and look at them. 16:9 versions: set `"size": "1920x1080"` and use landscape scenes.
  
  **Real product motion:** for a web app the user can run, record the actual flow with Playwright
  (`marketingskills/video/references/product-demo-recording.md`) and use it as a scene source or
  standalone demo. **Voice/avatars:** if HeyGen, ElevenLabs or similar is connected, generate the
  voiceover/avatar from the script and mux it in with ffmpeg; label AI avatars. Otherwise the
  captions carry the message, and face-cam clips are tasks for the user in the calendar.
  
  ## Posters and print
  
  If `/make-poster` is installed, use it (it reads the same README/brand and has print checks).
  Otherwise: `poster.html` + `render.py … poster.pdf` for print and `… poster.png` for a preview.
  QR: set `qr_url` (with `utm_source=poster`) in the data file; needs `pip install segno`.
  Monochrome variant: designed black-on-white, not a filter. Tell the user: print at 100%, A3/11×17,
  matte 150 gsm.
  
  ## Launch kit (produce once, before day 0)
  
  OG image · Product Hunt gallery (1270×760, up to 6, real UI) + 60 s demo · X/LinkedIn banners ·
  launch-day thread and post · launch email · 3 short videos (trailer, 1 feature, 1 "how it works") ·
  directory blurbs at 3 lengths (`directory-submissions/references/positioning-variations.md`) ·
  press/newsletter pitch · FAQ replies for the top objections in the context doc.
  

• launch-autopilot/references/autopilot.md4.8 KBd0172ace672bupstream ↗

  # Autopilot: queue, change, refill, review
  
  The queue is the source of truth: `marketing/queue.json`, managed only through
  `<skill>/scripts/contentq.py` (it keeps IDs unique, adds UTMs, saves atomically).
  Statuses: `draft → approved → scheduled → posted`, plus `needs_review` and `skipped`.
  `kind`: `launch`/`feature`/`fixed` posts keep their date; `evergreen` posts can move.
  
  ## queue / today / week
  
  `contentq.py status` (counts, `runway_days`, `refill_needed` when < 14 days) ·
  `contentq.py due --days 1` (today) · `--days 7` (week). For today/week, show each post's
  platform, time, copy and asset paths (send the files), flag anything still `draft` or
  `needs_review`, and list non-post tasks due from `calendar.md`.
  
  ## New feature (the "something new shipped" case)
  
  1. **Find what's new** since `state.json` → `last_commit` (or last changelog version):
     merged PRs, `git log <last>..HEAD --no-merges`, changelog entries, docs diffs, or the user's
     description. Follow `marketingskills/launch/references/shipped-changes.md`: only what
     customers can use today; write "You can now ___" for each; tier as major / medium / minor.
  2. **Update the context doc:** add rows to the Feature inventory, bump version + changelog line.
     Capture fresh screenshots of the feature.
  3. **Plan the mini-launch** by tier and inject it:
  
  | Tier | Posts (days from release R) |
  |---|---|
  | Major | R−2 teaser (real UI peek) · R launch post on every channel + video · R+1 how-to carousel · R+3 use-case/story · R+7 recap or tip; email to list; changelog; consider Product Hunt relaunch if never done or ≥6 months since |
  | Medium | R post on the 1–2 best channels + short clip · R+4 tip post · changelog + email segment |
  | Minor | Batch into the next weekly "what's new" post / changelog |
  
     Write them with `"kind": "feature"`, `"source": "feature:<slug>"`, then
     `contentq.py inject --posts new.json`. Evergreen posts on those slots move to the next free day
     per platform automatically; report which moved.
  4. **Audit** (below) for claims the feature changed, render the assets (`assets.md`), set
     `state.json.last_commit` to the commit you processed.
  
  ## Refill
  
  When `runway_days` < 14, or on the weekly run, top the queue up to the target (default 30 days):
  - Spread pillars per `strategy.md`; at most one direct-promo post in five.
  - Sources in order: Feature inventory items not posted in the last 60 days · objections and FAQs
    from the context doc · content atoms from new docs/blog/changelog (repurposing system in
    `marketingskills/social/GUIDE.md`) · top performers from Learnings, re-angled (reuse after
    90 days) · build-in-public notes from recent commits.
  - Dedupe: no two posts with the same angle within 30 days (compare titles/briefs in the queue).
  - Render assets only for the next 14 days; later posts keep copy + brief so they render against
    the current product.
  
  ## Review (weekly)
  
  Pull numbers the user can give or a connected tool can read (platform analytics, scheduler stats,
  signups by `utm_content` = post ID). Report top 3 / bottom 3 posts and why, follower and click
  trend, signups vs goal. Propose Learnings rows (format and bar in
  `marketingskills/product-marketing/GUIDE.md` §Maintaining Learnings); add only on approval. Then
  adjust: shift cadence toward formats that convert, retire angles that flop twice, and change
  upcoming drafts that contradict a learning.
  
  ## Audit (claim drift)
  
  After any change to pricing, plans, limits, names or features: list the statements that are now
  false, then `contentq.py flag --grep "<old claim>"` for each so those future posts become
  `needs_review`, and list site/docs/listing pages to update. Fix the flagged drafts.
  
  ## Schedule
  
  Offer three scheduled tasks, created with the environment's scheduling tool (in the Claude app:
  a scheduled task; elsewhere: a durable cron that runs the agent with the prompt). Each prompt must
  be standalone: name the repo/folder, this skill, and the command.
  
  | Task | Cadence | Prompt core |
  |---|---|---|
  | Daily brief | weekdays, 15 min before the first post time | "Run launch-autopilot `today` for <folder>: list today's posts with copy and files; flag drafts awaiting approval." |
  | Weekly run | Monday morning | "Run launch-autopilot `new-feature` (since state.json), then `audit`, `refill 30`, render the next 14 days, and `review` with whatever data is available. Draft only." |
  | Release watch | on the user's release cadence or daily | "Check <repo> for new tags/merged PRs since state.json; if any are customer-visible, run `new-feature`. Otherwise do nothing." |
  
  Guardrails for every scheduled run (from `marketingskills/marketing-loops/references/loop-guardrails.md`):
  draft and render only; never publish, send, submit or spend; idempotent via `state.json`
  (skip work already done); if the repo or queue can't be read, stop and report instead of guessing;
  most runs should end "checked, nothing to do".
  

• launch-autopilot/references/marketingskills/ad-creative/GUIDE.md26 KB322c3361edc0upstream ↗

  ---
  name: ad-creative
  description: "When the user wants to generate, iterate, or scale ad creative — headlines, descriptions, primary text, or full ad variations — for any paid advertising platform. Also use when the user mentions 'ad copy variations,' 'ad creative,' 'generate headlines,' 'RSA headlines,' 'bulk ad copy,' 'creative testing,' 'write me some ads,' 'Facebook ad copy,' 'Google ad headlines,' 'LinkedIn ad text,' 'static ads,' 'ad templates,' 'iMessage ad,' 'ChatGPT ad,' 'creative strategy,' 'creative roadmap,' 'creative retro,' 'hook writing,' 'creative review page,' 'motion video ad,' 'faceless video ad,' 'UGC ad,' 'greenscreen ad,' 'TikTok/Reels ad format,' 'Meta ad format tier list,' or 'creative format taxonomy.' Use it to produce or iterate ad copy at scale. Copy avoids AI tells like 'it's not X, it's Y' reveals. For campaign strategy and targeting, see ads. For landing page copy, see copywriting. Test hypotheses must be falsifiable, naming the metric, the comparison, and the expected direction."
  metadata:
    version: 2.12.1
  ---
  
  # Ad Creative
  
  You are an expert performance creative strategist. Your goal is to generate high-performing ad creative at scale — headlines, descriptions, and primary text that drive clicks and conversions — and iterate based on real performance data.
  
  ## Before Starting
  
  **Check for product marketing context first:**
  If `.agents/product-marketing.md` exists (or `.claude/product-marketing.md`, or the legacy `product-marketing-context.md` filename, in older setups), read it before asking questions. Use that context and only ask for information not already covered or specific to this task.
  
  Check its **Learnings** section before drafting: angles, offers, and formats already tested there shouldn't be re-proposed as new ideas, and active lessons apply unless the user says otherwise.
  
  Gather this context (ask if not provided):
  
  ### 1. Platform & Format
  - What platform? (Google Ads, Meta, LinkedIn, TikTok, Twitter/X)
  - What ad format? (Search RSAs, display, social feed, stories, video)
  - Are there existing ads to iterate on, or starting from scratch?
  
  ### 2. Product & Offer
  - What are you promoting? (Product, feature, free trial, demo, lead magnet)
  - What's the core value proposition?
  - What makes this different from competitors?
  
  ### 3. Audience & Intent
  - Who is the target audience?
  - What stage of awareness? (Problem-aware, solution-aware, product-aware)
  - What pain points or desires drive them?
  
  ### 4. Performance Data (if iterating)
  - What creative is currently running?
  - Which headlines/descriptions are performing best? (CTR, conversion rate, ROAS)
  - Which are underperforming?
  - What angles or themes have been tested?
  
  ### 5. Constraints
  - Brand voice guidelines or words to avoid?
  - Compliance requirements? (Industry regulations, platform policies)
  - Any mandatory elements? (Brand name, trademark symbols, disclaimers)
  
  ---
  
  ## How This Skill Works
  
  This skill supports four modes:
  
  ### Mode 1: Generate from Scratch
  When starting fresh, you generate a full set of ad creative based on product context, audience insights, and platform best practices.
  
  ### Mode 2: Iterate from Performance Data
  When the user provides performance data (CSV, paste, or API output), you analyze what's working, identify patterns in top performers, and generate new variations that build on winning themes while exploring new angles.
  
  The core loop:
  
  ```
  Pull performance data → Identify winning patterns → Generate new variations → Validate specs → Deliver
  ```
  
  ### Mode 3: Scaled Static Batches (Grounded)
  For recurring static ad production at volume (e.g., 50 concepts per batch), work from a **grounded inputs corpus** and the [static ad template library](references/static-ad-templates.md). Every concept must trace to real source material — see "Grounded Inputs" below. To run this on a daily or weekly cadence, see the daily-creative-drop loop in **marketing-loops**. To present a batch for client or stakeholder approval, produce a [creative review page](references/creative-review-page.md).
  
  For **text-led static headlines**, select treatments by the reader's awareness stage and deliver a mobile-readable visual spec using [references/awareness-headlines.md](references/awareness-headlines.md). It complements the static templates and hook system; numerical claims still need their own evidence.
  
  ### Mode 4: Creative Strategy Loop
  For deciding **which ads are worth making before making them**: synthesize three signal sources (account performance, customer language, external organic) into evidence-ranked concepts, branch the creative mix on account state (exploration vs. scaling), maintain a capacity-checked roadmap with production tiers, and run a monthly retro that feeds the next slate. The full system lives in [references/creative-roadmap.md](references/creative-roadmap.md); for hook generation and funnel-stage diagnosis inside any mode, load [references/hook-system.md](references/hook-system.md).
  
  ---
  
  ## Grounded Inputs
  
  Most AI ad generation fails on input grounding, not output quality: ungrounded generation produces plausible-sounding ads based on training data, not on what converts for this brand. For scaled production (Mode 3), maintain a durable inputs corpus:
  
  ```
  inputs/
    winning-ads/   10-20 screenshots of the highest-performing ads from the last 90 days
    reviews/       50-100 customer reviews (Trustpilot, G2, Amazon, App Store) as .md/.txt
    comments/      Top comments from existing ad campaigns — objections, unprompted praise, customer-raised angles
  brand/           Brand voice doc, hex codes, logo, product/screenshot assets
  outputs/         Dated batch folders (outputs/YYYY-MM-DD/)
  ```
  
  **Why each input matters:**
  - **Winning ads** carry the hooks, structures, and angles already proven for this brand
  - **Reviews** carry the exact language buyers use for pain, transformation, and unexpected benefits — pull copy from them verbatim rather than paraphrasing
  - **Ad comments** are the most-skipped and highest-value input: objections ("but does it work for X?") become FAQ Card ads, and unprompted praise surfaces angles you didn't write
  
  **Grounding rules:**
  - Every concept cites its source (which review, winning ad, or comment it traces to)
  - No invented claims, stats, or testimonials — ever
  - If `inputs/winning-ads/` or `inputs/reviews/` is empty, stop and ask the user to populate it before generating. Do not generate ungrounded concepts as a fallback.
  - Inputs decay: refresh `inputs/winning-ads/` as new ads scale; refresh `inputs/reviews/` and `inputs/comments/` monthly
  
  ---
  
  ## Platform Specs
  
  Platforms reject or truncate creative that exceeds these limits, so verify every piece of copy fits before delivering.
  
  ### Google Ads (Responsive Search Ads)
  
  | Element | Limit | Quantity |
  |---------|-------|----------|
  | Headline | 30 characters | Up to 15 |
  | Description | 90 characters | Up to 4 |
  | Display URL path | 15 characters each | 2 paths |
  
  **RSA rules:**
  - Headlines must make sense independently and in any combination
  - Pin headlines to positions only when necessary (reduces optimization)
  - Include at least one keyword-focused headline
  - Include at least one benefit-focused headline
  - Include at least one CTA headline
  
  ### Meta Ads (Facebook/Instagram)
  
  | Element | Limit | Notes |
  |---------|-------|-------|
  | Primary text | 125 chars visible (up to 2,200) | Front-load the hook |
  | Headline | 40 characters recommended | Below the image |
  | Description | 30 characters recommended | Below headline |
  | URL display link | 40 characters | Optional |
  
  ### LinkedIn Ads
  
  | Element | Limit | Notes |
  |---------|-------|-------|
  | Intro text | 150 chars recommended (600 max) | Above the image |
  | Headline | 70 chars recommended (200 max) | Below the image |
  | Description | 100 chars recommended (300 max) | Appears in some placements |
  
  ### TikTok Ads
  
  | Element | Limit | Notes |
  |---------|-------|-------|
  | Ad text | 80 chars recommended (100 max) | Above the video |
  | Display name | 40 characters | Brand name |
  
  ### Twitter/X Ads
  
  | Element | Limit | Notes |
  |---------|-------|-------|
  | Tweet text | 280 characters | The ad copy |
  | Headline | 70 characters | Card headline |
  | Description | 200 characters | Card description |
  
  For detailed specs and format variations, see [references/platform-specs.md](references/platform-specs.md).
  
  ---
  
  ## Generating Ad Visuals
  
  **To decide *which format to make next*** (before briefing any specific ad), consult the Meta creative format taxonomy in [references/meta-creative-formats.md](references/meta-creative-formats.md) — a prioritized S→F catalog of ~51 formats ranked by one question: is it a *unicorn scaler* that punctures cold net-new audiences, or a *supporting cast* member that only converts mid-funnel? Leads with the persona-based Andromeda context (why creator-fronted formats top the list), S-tier callouts (founder content, partnership ads, VSL), the A-tier bench, and explicit F-tier de-prioritization (press, podcast, notes-app fake-native). Use it to pick a format and build a portfolio; the how-to-build detail lives in the static/video references below. For the account-level kill/keep/scale math once ads are live, cross-reference the `ads` skill's the **ads** skill's Meta decision system reference.
  
  **For static ad structure**, use the template library in [references/static-ad-templates.md](references/static-ad-templates.md) — layout frameworks (Us vs. Them, Stat Callout, Review Card, Before/After, Founder Message, FAQ Card, Grid Static, Callout, and more) with copy slots, DTC and SaaS examples, and per-concept output format. Each template carries a **tier (S–F)** and **funnel role** (unicorn cold-scaler vs. mid-funnel supporting cast) so you reach for the right one first. Cycle through templates rather than clustering on favorites — but weight toward the S/A tiers when the goal is cold net-new reach.
  
  **For iOS-native reveal video ads** — iMessage chat reveals (scripted thread unfolds bubble-by-bubble: screenshot hook → friend asks "what app is that?" → brand + promo code reveal → end card), ChatGPT reveals (typed question → streaming answer), Apple Notes reveals (a confessional note typed live), and AirDrop reveals (an incoming share where the accept-tap is the reveal) — see [references/imessage-video-ads.md](references/imessage-video-ads.md) for surface selection, the six concept angles, script and pacing rules, production routes (Playwright + ffmpeg pipeline, Remotion), craft details that sell the illusion, and the grounding/compliance rules for dramatized conversations (strictest for fabricated AI answers).
  
  **For faceless motion-style video ads** — fully generated 15–45s concept/explainer videos (styled poster stills → image-to-video "living" motion → TTS narration → word-timed captions; roughly $3–6 and ~15 minutes per finished video) — see [references/motion-video-ads.md](references/motion-video-ads.md) for the provider-agnostic pipeline, a nine-style visual library with fill-in prompt formulas — five characterful looks (screen-print collage, flat vector explainer, papercraft diorama, pop-art comic, claymation) plus four brand-flexible token-driven styles (monoline editorial, Swiss typographic, wireglow, duotone screenprint) driven by a brand-slots contract (FIELD / INK / ACCENT / TYPE FEEL) — the motion prompt formula, and hard-earned QC gotchas (maker-hands intrusion, final-two-seconds drift, caption/label collision, TTS/whisper sound-alikes).
  
  **For creator/UGC short-form video** — a tiered format library (reaction+demo hard cuts, "no yapping" split-screen tutorials, greenscreen reactions, plus Yapper, amateur investigation, David & Goliath, authority, VSL, green-screen commentary, conversation, duet/reaction, ASMR, and street-interview formats, each with a scale-vs-support tier and mechanics) and founder / organic-vlog structures (hero's journey, math, shiny-object, niche-guide, the three-capture shooting system, and the 0.5–1s cut formula) for TikTok/Reels/Shorts growth and paid — see [references/short-form-video-specs.md](references/short-form-video-specs.md). It also carries the **vertical video production spec** that applies to *all* 9:16 video this skill makes: the cross-platform safe-zone band (720×1200 text-safe area — the most-missed constraint), the classic TikTok caption recipe (white fill + black stroke, no pill), static-caption auto-sizing, and the organic-vs-baked-music decision that affects reach. Load it before producing any vertical video.
  
  For image and video generation tools, see [references/generative-tools.md](references/generative-tools.md) for the complete guide covering:
  
  - **Image generation** — Nano Banana Pro (Gemini), Flux, Ideogram for static ad images
  - **Video generation** — Veo, Kling, Runway, Seedance, Higgsfield for video ads
  - **Voice & audio** — ElevenLabs, OpenAI TTS, Cartesia for voiceovers, cloning, multilingual
  - **Code-based video** — Remotion for templated, data-driven video at scale
  - **Platform image specs** — Correct dimensions for every ad placement
  - **Cost comparison** — Pricing for 100+ ad variations across tools
  
  **Recommended workflow for scaled production:**
  1. Generate hero creative with AI tools (exploratory, high-quality)
  2. Build Remotion templates based on winning patterns
  3. Batch produce variations with Remotion using data feeds
  4. Iterate — AI for new angles, Remotion for scale
  
  ---
  
  ## Generating Ad Copy
  
  ### Step 1: Define Your Angles
  
  Before writing individual headlines, establish 3-5 distinct **angles** — different reasons someone would click. Each angle should tap into a different motivation.
  
  **Common angle categories:**
  
  | Category | Example Angle |
  |----------|---------------|
  | Pain point | "Stop wasting time on X" |
  | Outcome | "Achieve Y in Z days" |
  | Social proof | "Join 10,000+ teams who..." |
  | Curiosity | "The X secret top companies use" |
  | Comparison | "Unlike X, we do Y" |
  | Urgency | "Limited time: get X free" |
  | Identity | "Built for [specific role/type]" |
  | Contrarian | "Why [common practice] doesn't work" |
  
  ### Step 2: Generate Variations per Angle
  
  For each angle, generate multiple variations. Vary:
  - **Word choice** — synonyms, active vs. passive
  - **Specificity** — numbers vs. general claims
  - **Tone** — direct vs. question vs. command
  - **Structure** — short punch vs. full benefit statement
  
  ### Step 3: Validate Against Specs
  
  Before delivering, check every piece of creative against the platform's character limits. Flag anything that's over and provide a trimmed alternative.
  
  ### Step 4: Organize for Upload
  
  Present creative in a structured format that maps to the ad platform's upload requirements.
  
  ---
  
  ## Iterating from Performance Data
  
  When the user provides performance data, follow this process:
  
  ### Step 1: Analyze Winners
  
  Look at the top-performing creative (by CTR, conversion rate, or ROAS — ask which metric matters most) and identify:
  
  - **Winning themes** — What topics or pain points appear in top performers?
  - **Winning structures** — Questions? Statements? Commands? Numbers?
  - **Winning word patterns** — Specific words or phrases that recur?
  - **Character utilization** — Are top performers shorter or longer?
  
  ### Step 2: Analyze Losers
  
  Look at the worst performers and identify:
  
  - **Themes that fall flat** — What angles aren't resonating?
  - **Common patterns in low performers** — Too generic? Too long? Wrong tone?
  
  ### Step 3: Generate New Variations
  
  Create new creative that:
  - **Doubles down** on winning themes with fresh phrasing
  - **Extends** winning angles into new variations
  - **Tests** 1-2 new angles not yet explored
  - **Avoids** patterns found in underperformers
  
  ### Step 4: Document the Iteration
  
  Track what was learned and what's being tested:
  
  ```
  ## Iteration Log
  - Round: [number]
  - Date: [date]
  - Top performers: [list with metrics]
  - Winning patterns: [summary]
  - New variations: [count] headlines, [count] descriptions
  - New angles being tested: [list]
  - Angles retired: [list]
  ```
  
  ---
  
  ## Writing Quality Standards
  
  ### Headlines That Click
  
  **Strong headlines:**
  - Specific ("Cut reporting time 75%") over vague ("Save time")
  - Benefits ("Ship code faster") over features ("CI/CD pipeline")
  - Active voice ("Automate your reports") over passive ("Reports are automated")
  - Include numbers when possible ("3x faster," "in 5 minutes," "10,000+ teams")
  
  **Avoid:**
  - Jargon the audience won't recognize
  - Claims without specificity ("Best," "Leading," "Top")
  - All caps or excessive punctuation
  - Clickbait that the landing page can't deliver on
  - Shortened or nicknamed product names — use the exact product name the
    brief gives, in every field of every concept, unless a short form is
    explicitly approved
  
  ### Test Hypotheses That Can Lose
  
  When a concept ships with a test hypothesis, write one that a result can
  prove wrong. "This will resonate with renters" cannot lose; "beats the
  control on CTR among renters" can.
  
  - Name the metric (CTR, CVR, CPA, thumb-stop rate) and the comparison —
    against which control or sibling concept, in which audience
  - State the expected direction, and a magnitude when a baseline exists
    ("+15% CTR vs. Concept A")
  - The hypothesis should follow from the angle's motivation, so a win or a
    loss teaches you something about the audience, not just the asset
  
  ### No AI Tells
  
  Ad copy that reads as generated looks like every other ad in the feed, and generating at volume multiplies whatever tic the first draft has. Check the whole batch.
  
  Never write these:
  - **Contrast reveals**: "It's not X, it's Y." "Not because X. Because Y." State Y directly, with the reason.
  - **Negation lists**: "No X, no Y, no Z." Say what does happen. One plain absence ("No card required") is fine.
  - **Trailing pile-ons**: a full claim, then a comma and more restating clauses. End the sentence at the claim.
  - **Self-answered questions and colon reveals**: "The result? 3x faster." "The best part: it learns." FAQ questions and a question in the reader's own voice are fine.
  - **Stock phrases**: "Say goodbye to," "X, reimagined," "Unlock the power of," "Take it to the next level," "Here's the thing."
  - **Em dashes** in headlines, descriptions, and primary text.
  
  Ad-specific tells:
  - **Stacked negations to fit a character limit**: "No setup. No fees. No contracts." Keep the one that matters most and use the space for a fact.
  - **Hook slop**: a generic "POV:", "Stop scrolling," "Here's what nobody tells you about X." Earn the next second with something specific to the viewer. A POV hook is fine when the situation is hyper-specific ("POV: it's 3pm and you're on your fourth coffee").
  - **CTA slop**: "Get started today," "Join thousands of happy customers." Name the action and what they get.
  
  Across a batch, vary the sentence shapes. Ten variations that all open the same way read as generated, even when each one is fine alone. For the full blacklist, use the **copywriting** skill's AI-tells reference.
  
  ### Descriptions That Convert
  
  Descriptions should complement headlines, not repeat them. Use descriptions to:
  - Add proof points (numbers, testimonials, awards)
  - Handle objections ("No credit card required," "Free forever for small teams")
  - Reinforce CTAs ("Start your free trial today")
  - Add urgency when genuine ("Limited to first 500 signups")
  
  ---
  
  ## Output Formats
  
  ### Standard Output
  
  Organize by angle, with character counts:
  
  ```
  ## Angle: [Pain Point — Manual Reporting]
  
  ### Headlines (30 char max)
  1. "Stop Building Reports by Hand" (29)
  2. "Automate Your Weekly Reports" (28)
  3. "Reports Done in 5 Min, Not 5 Hr" (31) <- OVER LIMIT, trimmed below
     -> "Reports in 5 Min, Not 5 Hrs" (27)
  
  ### Descriptions (90 char max)
  1. "Marketing teams save 10+ hours/week with automated reporting. Start free." (73)
  2. "Connect your data sources once. Get automated reports forever. No code required." (80)
  ```
  
  ### Bulk CSV Output
  
  When generating at scale (10+ variations), offer CSV format for direct upload:
  
  ```csv
  headline_1,headline_2,headline_3,description_1,description_2,platform
  "Stop Manual Reporting","Automate in 5 Minutes","Join 10K+ Teams","Save 10+ hrs/week on reports. Start free.","Connect data sources once. Reports forever.","google_ads"
  ```
  
  ### Static Batch Output (Mode 3)
  
  For scaled static batches, save to a dated folder with an index:
  
  ```
  outputs/YYYY-MM-DD/
    INDEX.md        # every concept: template type + grounding source, scannable in 2 min
    concepts/       # one .md per concept: headline, body, visual description, image prompt, grounding
    images/         # generated images, if an image tool is configured
  ```
  
  Per-concept format is defined in [references/static-ad-templates.md](references/static-ad-templates.md). The human workflow this supports: open the folder, scan INDEX.md, pick the best 5-10 for testing — picking 5 winners from 50 concepts yields better creative than picking 5 from 10.
  
  ### Creative Review Page (client / stakeholder approval)
  
  When a person who isn't you needs to review and pick — a client, a partner, a stakeholder — produce a **creative review page**: a self-contained HTML artifact that presents each concept as an in-feed platform mockup (Instagram/Facebook, with a whitelist-handle toggle), breaks carousels into a labeled frame-by-frame storyboard, lets them toggle headline/copy variations, and discloses what's grounded in real assets. It's the visual upgrade to INDEX.md — a decision made off one link instead of by reading markdown. The template ships at [assets/creative-review-template.html](assets/creative-review-template.html) (one file, no build, hostable anywhere); populate its `DATA` object from your generated concepts. Full data model, grounding rules (the disclosure block is required), and delivery in [references/creative-review-page.md](references/creative-review-page.md).
  
  ### Iteration Report
  
  When iterating, include a summary:
  
  ```
  ## Performance Summary
  - Analyzed: [X] headlines, [Y] descriptions
  - Top performer: "[headline]" — [metric]: [value]
  - Worst performer: "[headline]" — [metric]: [value]
  - Pattern: [observation]
  
  ## New Creative
  [organized variations]
  
  ## Recommendations
  - [What to pause, what to scale, what to test next]
  ```
  
  ---
  
  ## Batch Generation Workflow
  
  For large-scale creative production (Anthropic's growth team generates 100+ variations per cycle):
  
  ### 1. Break into sub-tasks
  - **Headline generation** — Focused on click-through
  - **Description generation** — Focused on conversion
  - **Primary text generation** — Focused on engagement (Meta/LinkedIn)
  
  ### 2. Generate in waves
  - Wave 1: Core angles (3-5 angles, 5 variations each)
  - Wave 2: Extended variations on top 2 angles
  - Wave 3: Wild card angles (contrarian, emotional, specific)
  
  ### 3. Quality filter
  - Remove anything over character limit
  - Remove duplicates or near-duplicates
  - Flag anything that might violate platform policies
  - Ensure headline/description combinations make sense together
  
  ---
  
  ## Common Mistakes
  
  - **Writing headlines that only work together** — RSA headlines get combined randomly
  - **Ignoring character limits** — Platforms truncate without warning
  - **All variations sound the same** — Vary angles, not just word choice
  - **No CTA headlines** — RSAs need action-oriented headlines to drive clicks; include at least 2-3
  - **Generic descriptions** — "Learn more about our solution" wastes the slot
  - **Iterating without data** — Gut feelings are less reliable than metrics
  - **Generating without grounding** — Ungrounded concepts read like every other ad in the feed; feed the skill winning ads, reviews, and comments first
  - **Skipping the comments input** — Ad comments hold the objections and angles customers raise themselves; those usually convert best
  - **Testing too many things at once** — Change one variable per test cycle
  - **Retiring creative too early** — Allow 1,000+ impressions before judging
  
  ---
  
  ## Tool Integrations
  
  For pulling performance data and managing campaigns, see the [tools registry](https://github.com/coreyhaines31/marketingskills/blob/main/tools/REGISTRY.md).
  
  | Platform | Pull Performance Data | Manage Campaigns | Guide |
  |----------|:---------------------:|:----------------:|-------|
  | **Google Ads** | `google-ads campaigns list`, `google-ads reports get` | `google-ads campaigns create` | [google-ads.md](https://github.com/coreyhaines31/marketingskills/blob/main/tools/integrations/google-ads.md) |
  | **Meta Ads** | `meta-ads insights get` | `meta-ads campaigns list` | [meta-ads.md](https://github.com/coreyhaines31/marketingskills/blob/main/tools/integrations/meta-ads.md) |
  | **LinkedIn Ads** | `linkedin-ads analytics get` | `linkedin-ads campaigns list` | [linkedin-ads.md](https://github.com/coreyhaines31/marketingskills/blob/main/tools/integrations/linkedin-ads.md) |
  | **TikTok Ads** | `tiktok-ads reports get` | `tiktok-ads campaigns list` | [tiktok-ads.md](https://github.com/coreyhaines31/marketingskills/blob/main/tools/integrations/tiktok-ads.md) |
  
  ### Workflow: Pull Data, Analyze, Generate
  
  ```bash
  # 1. Pull recent ad performance
  node tools/clis/google-ads.js reports get --type ad_performance --date-range last_30_days
  
  # 2. Analyze output (identify top/bottom performers)
  # 3. Feed winning patterns into this skill
  # 4. Generate new variations
  # 5. Upload to platform
  ```
  
  > **Skip the plumbing.** Step 1 is the hard part to run yourself — the Google
  > Ads (or Meta / LinkedIn / TikTok) API, OAuth, and a reporting query per
  > account, repeated every time. [Magister](https://magistermarketing.com?ref=marketingskills)
  > is an autonomous marketing agent that runs on these exact skills and pulls
  > ad performance natively: its agent reads your accounts through typed,
  > approval-gated integrations with no setup, then applies this skill to the
  > result. If you're wiring these pulls up by hand, it's worth a look.>
  > *Disclosure: Magister is built by Corey Haines, who maintains this repository.*
  > To run the pull yourself instead, use the repo's ad platform CLIs (setup in
  > [tools/SETUP.md](https://github.com/coreyhaines31/marketingskills/blob/main/tools/SETUP.md)),
  > or a reporting connector such as Supermetrics or Coupler.
  
  ---
  
  ## Related Skills
  
  - **ads**: For campaign strategy, targeting, budgets, and optimization
  - **marketing-loops**: For running static batch generation on a recurring cadence (the daily-creative-drop loop)
  - **customer-research**: For mining reviews and comments when building the grounded inputs corpus
  - **copywriting**: For landing page copy (where ad traffic lands)
  - **ab-testing**: For structuring creative tests with statistical rigor
  - **marketing-psychology**: For psychological principles behind high-performing creative
  - **copy-editing**: For polishing ad copy before launch
  

• launch-autopilot/references/marketingskills/ad-creative/references/awareness-headlines.md6.6 KB5a804c029c40upstream ↗

  # Awareness-Based Headline Creative
  
  Use for text-led static concepts, especially B2B feed ads. These are compact treatments within the existing angle and template workflow; they do not replace audience research, the hook system, or platform specs.
  
  Concept lineage: the maintainer's #404 follow-up to the ivangfalco/ads-skills remix. Re-expressed independently and reconciled with this repo's grounding and AI-tells rules; no source copy or creative assets imported.
  
  ## Choose the Reader's Next Step
  
  | Awareness | What the reader needs | Useful treatments | CTA direction |
  |---|---|---|---|
  | Unaware / unfamiliar with the category | Recognize a specific lived situation | Feeling, conversation | Learn about the situation or mechanism |
  | Problem-aware | See a credible path out of a named friction | Pain + outcome, time-anchored friction | See the workflow or explanation |
  | Solution-aware | Understand a concrete way this approach differs | State change, documented statistic | Compare the mechanism or watch a demo |
  | Product-aware | Resolve an objection with specific proof | Statistic, pain + outcome | Inspect proof, try, or book the relevant next step |
  
  Stage is a working hypothesis about this audience, not a diagnosis based on the platform alone. If unknown, state the assumption and propose two distinct stage hypotheses. A formula alone cannot prove an ad will convert.
  
  ## Six Treatments
  
  The examples below are invented illustrations of structure, **not** approved product claims, real customer quotes, or ready-to-run ads. Replace their facts with the user's verified corpus. Each treatment can serve multiple stages; choose based on what the reader already knows.
  
  | Treatment | Construction and guardrail | Illustrative SaaS example | Illustrative DTC example |
  |---|---|---|---|
  | **Feeling** | Name a recognizable feeling tied to a specific work/life moment. Avoid vague empowerment or a forced positive/negative reveal. | “Leave Friday with the forecast finished.” | “Dinner sorted before the commute home.” |
  | **Conversation** | Two short lines from a recognizable situation. Use an actual permitted exchange, or label invented dialogue as a dramatization; never fabricate testimonial attribution. | “Is this the final sheet?” / “There are three final sheets.” | “What's for dinner?” / “I'm still on the train.” |
  | **State change** | Show the current and proposed workflow with concrete artifacts. State what changes; don't force “not X, Y” copy or unsupported competitor claims. | “Bring the three approval threads into one queue.” | “Pack tomorrow's lunch while tonight's dinner cooks.” |
  | **Time-anchored friction** | Name an obsolete or repetitive process and its actual moment. Critique the process without shaming the buyer or inventing a trend. | “Month-end still starts with copying CSVs.” | “The Sunday grocery list starts over again.” |
  | **Documented statistic** | One supported number plus the population, period, or meaningful qualifier. Keep its real precision; rounded numbers are not evidence of fakery. | “Pilot teams cut weekly reconciliation from 6 hours to 2.” | “Three dinners packed in one delivery.” |
  | **Pain + outcome** | One named friction and a concrete next action/outcome, usually under ten words. Brevity is a draft constraint, not permission to drop a material qualifier. | “Find the missing invoice before close.” | “Get dinner ready between calls.” |
  
  Read each draft against the existing AI-tells guidance. Do not produce six near-identical sentences just to fill a formula menu. Preserve customer language where it is permitted and relevant; facts can ground a paraphrase without becoming a fabricated quote.
  
  ## Gather Proof Before Copy
  
  Build a small evidence sheet: source ID, verbatim phrase or product fact, audience, date, allowed usage, and limitations. Aim for five useful customer phrases when available, across more than one perspective. If the available corpus is smaller, report the gap and reduce diversity claims; do not invent quotes to meet a count. Existing Grounded Inputs requirements still apply to scaled Mode 3 batches.
  
  Separate **language evidence** (“the export takes forever”) from **claim evidence** (a measured reduction across a defined pilot). A complaint supports the pain angle; it does not substantiate a numerical performance promise. Preserve a pilot's sample size and period in adjacent readable copy or withhold the statistical concept when a truthful presentation cannot fit.
  
  ## Make the Headline the Visual
  
  Apply this treatment to Headline Statement or Stat Callout from the static library when the words carry the concept. It is a production hypothesis, not a guarantee that text-only ads beat every other format.
  
  - Start with one dominant sentence and a bold, legible sans-serif face. As a design starting point, let the headline occupy roughly 50–70% of the composition; adjust after actual-size testing.
  - Use intentional line breaks that keep phrases together. Keep the product/logo secondary unless recognizing the product is the concept's job.
  - Test a dark background with light text, or a strong brand-colored background with contrasting text. Choose from the user's actual palette and verify readability; avoid a color prescription based on an unverified feed theme.
  - Include the audience's specific moment, one defensible idea, and enough qualification to read truthfully. Exclude stock imagery competing with the sentence, tiny disclaimers, fake review UI, extra badges, and an unsupported second claim.
  - Make a preview at the **actual mobile feed display size**, not only on a desktop canvas. Check that a reviewer can read the entire headline and its material qualifiers without zooming. If not, shorten the claim or change the layout; never solve it by shrinking required qualifications.
  - Get current export dimensions, cropping, safe areas, and text-field limits from the platform-spec reference and the selected placement. The 50–70% layout suggestion is not a platform rule or a text-coverage approval threshold.
  
  ## Deliver and Learn
  
  For each concept, provide: audience/stage assumption, distinct angle, treatment + static template, headline, supporting qualification, CTA, source IDs, and visual specification with mobile-readability check. Mark evidence gaps and keep output as concepts for review unless publication is already authorized.
  
  Test stage/angle hypotheses before fine font changes. Compare the relevant downstream qualified outcome with the existing control, keeping offer and audience stable where possible. Strong CTR with weak qualified conversion is a reason to examine the promise and landing-page continuity, not proof of a winning headline.
  

• launch-autopilot/references/marketingskills/ad-creative/references/creative-review-page.md9.4 KB5b604fc7c91cupstream ↗

  # The Creative Review Page
  
  A shareable, self-contained web page that presents generated ad concepts for a client or stakeholder to **review and pick** — the visual upgrade to `INDEX.md`. Where the markdown outputs are built for the operator, the review page is built for the person approving the spend: it shows each concept as an in-feed platform mockup, breaks carousels into a labeled frame-by-frame storyboard, lets them toggle copy variations, and discloses what's grounded in real assets.
  
  The template ships at [assets/creative-review-template.html](../assets/creative-review-template.html). It's one file — inline CSS and JS, no build, no dependencies, no network. Open it locally, host it on any static host (Vercel/Netlify/GitHub Pages), or hand off the `.html` file directly.
  
  ## When to produce one
  
  - **Presenting a batch for approval** — after Mode 1 or Mode 3 generation, package the top concepts into a review page instead of (or alongside) `INDEX.md`. Picking 5 of 50 is a *visual* decision; a client shouldn't have to read markdown to make it.
  - **Pitching a whitelist / co-branded partnership** — the format the source pattern was built for: show the partner exactly what the ad looks like under each handle, with the rollout mechanics spelled out.
  - **A monthly slate review** (Mode 4) — render the slate's concepts so the account-state call and the pick happen off one link.
  
  Don't produce one for a single headline tweak or a quick internal gut-check — the markdown output is faster. Reach for the review page when a human who isn't you needs to choose.
  
  ## How it's built
  
  The template renders entirely from a JSON block near the top of the file — `<script type="application/json" id="review-data">`. Populate it from your generated concepts and everything else renders — tabs, previews, storyboard, copy panel. You do not edit the render code below the data block. The annotated model below is shown with `//` comments for readability; **the file itself is strict JSON** — no comments, no trailing commas (see "Populating the data safely").
  
  ### Data model
  
  ```jsonc
  {
    project: {
      brand: "Truvani",              // required
      agency: "Light Labs",          // optional — adds the co-brand line + the default handle fallback (partner label/initials)
      date: "2026-07-12",            // optional
      note: "one-line context"       // optional
    },
    platforms: ["instagram", "facebook"],   // previews to offer; first is the default. Supported: instagram, facebook
    concepts: [                              // each concept is one strategic ANGLE (see SKILL.md "Define Your Angles")
      {
        name: "Heavy-Metal Proof",           // required — the angle name
        tagline: "Lifestyle hero, then the lab results",   // one line, what makes this concept distinct
        handles: [                            // optional. 1 entry = normal post; 2 = whitelist handle toggle
          { name: "truvani", partner: "Paid partnership with lightlabs", initials: "TV" },
          { name: "Light Labs", partner: "Paid partnership with truvani", initials: "LL" }
        ],
        frames: [                             // 1 frame = single ad; multiple = carousel storyboard
          {
            label: "Hook",                    // the frame's job in the narrative arc
            prompt: "Product bag hero on soft pink, gold-lace overlay",  // image description (shown as placeholder if no image)
            image: "images/heavy-metal-01.png",   // optional — local path/file URL or data URI; omit for text-only concepts
            headline: "Finally, a plant-based protein that's third-party tested for heavy metals.",  // optional per-frame overlay
            headlineTheme: "dark"             // optional: "dark" (default, white text) or "light" (dark text on light imagery)
          }
          // … one object per frame
        ],
        headlines: [                          // selectable variations; the picked one overlays frame 1 in the preview
          "Finally, a plant-based protein that's third-party tested for heavy metals.",
          "We tested our protein for heavy metals. Here's what an independent lab found.",
          "Most protein powders are never tested for heavy metals. Ours is."
        ],
        primaryText: "The caption / body copy.",
        likes: "6,240",                       // optional — Instagram like count; omit and no count is shown
        destination: { url: "shop.truvani.com", cta: "Shop now", offer: "72% OFF Protein Starter Kit" },
        rollout: {                            // optional — the mechanics of how this runs (whitelist, launch plan)
          title: "How the whitelist runs",
          steps: ["step 1", "step 2", "…"]
        },
        grounding: "What in this concept is real — the required disclosure. See below."
      }
      // … 2–4 concepts is the sweet spot; more than that and the tabs stop being a decision
    ]
  }
  ```
  
  ### The frame storyboard = a carousel narrative arc
  
  A concept's `frames` are its storyboard. Label each frame by the *job it does*, not its content — `Hook`, `The problem`, `The results`, `The ask`. This is the same narrative-arc thinking as the carousel frameworks: a proof-led concept is literally Hook → Problem → Mechanism → Results → Context → Ask. For the five reusable carousel arcs (Value-Stack, Problem-Proof, Hack List, Rant Callout, Demo Walkthrough), see `carousel-frameworks.md` in the **social** skill and pick the arc that fits the angle before writing frames.
  
  ### Images vs. placeholders
  
  Every frame renders one of two ways:
  - **`image` provided** — the real creative (from the Mode 3 `images/` folder or a data URI) fills the frame.
  - **`image` omitted** — a styled placeholder shows the frame `label` + `prompt`. This is the intended state for concepts that are copy + image-prompt but not yet rendered to image — the review page is useful *before* images exist, and stays useful as they get filled in.
  
  Remote and protocol-relative image URLs are blocked, including URL spellings the browser normalizes. Download authorized creative assets into the local `images/` folder and keep paths relative when hosting or sharing; hosted relative assets still load from that host. This restriction applies to the supplied image sources, not a sandbox for arbitrary edits to the HTML or an assurance about a hosting server.
  
  Ship review pages with placeholders freely; they communicate the concept. Swap in images as they're generated.
  
  ## Grounding — the disclosure block is required
  
  Every concept must carry a `grounding` line, and it must be true. This is the same rule as the Grounded Inputs corpus, surfaced to the client: state exactly what is real (which lab panel, which review, which product photography) and, by omission, what is illustrative. The source pattern's line is the model — *"Results are Truvani's actual Light Labs panel (Vanilla, tested Nov 13, 2025). Imagery is Truvani's own product & lifestyle photography."*
  
  Never present invented stats, fabricated test results, or stock imagery as the brand's own. If a concept's proof isn't real yet, the grounding line says so ("Results shown are illustrative pending the lab panel") — a review page that launders fiction as fact is worse than no review page.
  
  ## Populating the data safely
  
  The `DATA` lives in a `<script type="application/json" id="review-data">` block — it's inert data (parsed with `JSON.parse`), not executable code, so a value can never run as script. Two rules when you write it:
  
  - **Valid JSON only** — double-quoted keys and strings, no comments, no trailing commas. (The page shows a clear error banner if the JSON is malformed, so a typo fails loud, not silent.)
  - **Escape `<` as `<` in every text value.** A value literally containing `</script>` would otherwise close the data block early. Since agents write the JSON, apply this escape mechanically to all string values. All values are HTML-escaped again at render time, so this is defense-in-depth, but the source-level escape is the one that matters — do it.
  
  ## Producing and delivering it
  
  1. Copy `assets/creative-review-template.html` into the batch's output folder as `review.html` (e.g. `outputs/YYYY-MM-DD/review.html`).
  2. Replace the `DATA` object with the real project — concepts, frames, copy, grounding. Populate `image` paths for any frames you've rendered (keep them relative to the html file so the folder stays portable).
  3. Verify it renders: open it in a browser, click through every concept tab, both platform and handle toggles, and each frame in the storyboard.
  4. Deliver: hand off the folder (html + `images/`), or host it. For a client link, `vercel deploy` or any static host works — it's a single page with local assets.
  
  Keep the review page next to the markdown outputs, not instead of them: `INDEX.md` and the per-concept files remain the operator's record and the grounding audit trail; `review.html` is the approval surface built on top.
  
  ## Common mistakes
  
  - **Too many concepts** — 2–4 tabs is a decision; 10 is a menu nobody finishes. Curate before you present.
  - **Unlabeled or content-labeled frames** — label by narrative job (`The proof`), not by what's pictured (`Table screenshot`).
  - **Missing or dishonest grounding** — every concept discloses what's real; illustrative proof is labeled illustrative.
  - **Editing the render code** — everything is data-driven; if something won't show, it's a `DATA` field, not the JS.
  - **Absolute image paths** — keep image paths relative so the output folder can be zipped, moved, or hosted intact.
  

• launch-autopilot/references/marketingskills/ad-creative/references/creative-roadmap.md8.8 KBf5d0322e642fupstream ↗

  # The Creative Strategy Loop
  
  Generation (Modes 1–3) answers "make me ads." This reference answers the question that comes first: **which ads are worth making, in what order, at what production cost** — and the retro that turns each month's results into next month's plan. It's the standing operating loop of a creative strategist, run by an agent with a human deciding.
  
  ```
  Signals → Concepts (evidence-ranked) → Roadmap (tiered, capacity-checked) → Briefs → [Modes 1–3 produce] → Monthly retro → back into the icebox
  ```
  
  ---
  
  ## Step 1: Read the Three Signals
  
  Creative direction comes from synthesis across three independent signal sources. One source alone misleads: the account tells you what worked *among things you've tried*, customers tell you why they buy *in their words*, and organic content tells you what the audience *chooses to watch when nobody's paying*.
  
  | Signal | What to pull | How |
  |---|---|---|
  | **Account performance** | Winners/losers by angle, hook, format; funnel metrics per concept (see [hook-system.md](hook-system.md) diagnostic funnel); fatigue state | `google-ads` / `meta-ads` / `linkedin-ads` / `tiktok-ads` CLIs (see Tool Integrations in SKILL.md) |
  | **Customer/brand** | Verbatim pain/desire/objection language; unexpected use cases; who's *actually* buying vs. who's targeted | The Grounded Inputs corpus (`inputs/reviews/`, `inputs/comments/`), sales-call notes, support themes — per **customer-research** |
  | **External organic** | What the niche watches unpaid: top organic content, its hooks, formats, vocabulary; competitor ads running long enough to be presumed working | **scraping**, the social listening tooling in **social**, ad libraries, **competitor-profiling** |
  
  **Cadence:** a monthly deep dive (60–90 min, all three sources, feeds the monthly roadmap) plus a weekly ~20-minute refresh (what changed: new winners/losers, new review themes, anything spiking organically). Research beyond what the next decision needs is busywork — every synthesis session should end in concepts, not notes.
  
  **Trust rule:** every insight the agent surfaces must carry its receipt — which review, which ad's metrics, which organic post. An insight without a source doesn't enter the icebox. (Same grounding rules as everything else in this skill.)
  
  ---
  
  ## Step 2: Turn Signals into Evidence-Ranked Concepts
  
  A **concept** is one testable creative hypothesis: *segment × motivation × angle × format*, with its evidence attached. "UGC for moms" is not a concept; "new-parent insomniacs (per 40+ reviews mentioning 3am feeds) × 'quiet enough to not wake the baby' × before/after demo × POV night-shot video" is.
  
  Rank every concept by the strongest evidence supporting it:
  
  | Tier | Evidence | Weight |
  |---|---|---|
  | 1 | Your own account: a converting ad with the same angle/segment | Strongest — iterate and extend |
  | 2 | Your customers verbatim: recurring review/call language | Strong — build new creative on it |
  | 3 | Competitor creative running 60+ days (presumed working) | Good — adapt the angle, never the ad |
  | 4 | Organic engagement in the niche (unpaid views/saves on the theme) | Moderate — validate cheaply first |
  | 5 | Cross-niche pattern (worked in an adjacent category) | Weak — icebox until corroborated |
  | 6 | Team hunch, no external signal | Weakest — low-fi test or drop |
  
  Higher evidence earns roadmap *priority* — an earlier slot in the slate. Production tier is a separate call, set by validation strength, existing assets, capacity, and risk: even a tier-2 customer-language concept starts low-fidelity until it shows a funnel signal. Hunches aren't banned — they're just cheap and last.
  
  ---
  
  ## Step 3: Branch on Account State
  
  The right creative mix depends on which of two states the account is in. Diagnose before roadmapping — a plan built for the wrong state wastes the month.
  
  **Exploration state** — nothing (or nothing new) is working:
  - Go **wide, not deep**: mostly net-new concepts across different segments and angles; keep iterations to a small minority — iterating on losers multiplies losers
  - **Redefine "win" per-metric**: with no full-funnel winners, a single-metric improvement (a hold-rate lift, a CPC drop, a CVR bump) on any test is a hit worth pulling on — see the diagnostic funnel
  - Iterate **only on hits**; everything else stays exploratory
  - Common root causes to check while testing: the creative is boring (safe, seen-before), the message is overcomplicated, the offer/UVP is unclear, or CPMs are punishing a too-narrow audience
  
  **Scaling state** — one or more concepts are converting profitably:
  - Go **deep on the winner** while it's open: a winner-led slate of visually-distinct variations of the winning concept (same message, new execution — near-duplicates mostly cannibalize the original's reach and teach you nothing new, so variations must look meaningfully different), plus a remix lane (tonal/emotional re-executions of it) and sub-angle probes drilling *into* the winning segment; tune the split to budget, fatigue speed, and production velocity
  - Keep a small exploration allocation alive even mid-scale — winners fatigue, and the next winner is rarely an iteration of the current one
  - Speed matters more in this state: a scaling window is finite
  
  ---
  
  ## Step 4: The Roadmap Artifact
  
  Maintain one living document (suggested: `roadmap.md` beside the Grounded Inputs corpus) with three horizons:
  
  ```
  ## Icebox        — every concept, evidence tier + source attached, nothing scheduled
  ## This quarter  — 2-4 themes chosen from the icebox (the bets), with why-now
  ## This month    — the slate: concept | evidence tier | production tier | owner | status
  ```
  
  Each monthly-slate concept gets a **production tier**:
  
  | Tier | Cost | What it is | Use for |
  |---|---|---|---|
  | **T1 — Iteration** | Hours | New hook/caption/crop on an existing asset | Extending proven winners |
  | **T2 — Remix** | Days | New creative from existing footage/assets/AI generation | Concepts with decent evidence or a first low-fi signal |
  | **T3 — Production** | Weeks | Net-new shoot, creators, full build | Only angles with own-account proof or a prior low-fi funnel signal (fidelity ladder in [hook-system.md](hook-system.md)) |
  
  **Capacity check — the rule that keeps roadmaps honest:** count what the team (or the AI pipeline) can produce *at quality* this month, and roadmap to that number. A 20-concept slate against 8 concepts of real capacity doesn't produce 20 ads; it produces 20 compromised ones and a burned-out team. Cut by evidence rank until the slate fits.
  
  From the slate, generate **one brief per concept** (segment, motivation + verbatim source, angle, format, hook matrix rows, production tier, success metric) and hand each to Modes 1–3 for production.
  
  ---
  
  ## Step 5: The Monthly Creative Retro
  
  Last step of the loop, first input of the next one. One artifact per month (suggested: `retros/YYYY-MM.md`):
  
  ```
  ## Winners     — concept, the funnel numbers, and the WHY (which element earned it)
  ## Losers      — concept, where in the funnel it died, hypothesis for why
  ## Metric wins — full-funnel losers with one strong metric (these are leads, not losses)
  ## Learnings   — pattern-level notes → written back into the icebox as new/revised concepts
  ## Kills       — concepts retired from the icebox, with reason
  ## Next slate  — first draft of next month, updated evidence ranks
  ```
  
  Retro rules:
  
  - **Judge concepts, not ads.** Three executions of one concept failing says the concept is wrong; one failing says the execution was.
  - **Read the funnel, not the ROAS column.** The diagnostic funnel says *what* to fix; ROAS alone says only *that* something is broken.
  - **Enough data before verdicts** — respect the impression/spend thresholds in Common Mistakes and the **ads** skill's decision systems; a two-day read is a coin flip.
  - **Every learning lands somewhere**: icebox update, evidence re-rank, or kill. A retro that changes nothing in the roadmap was a meeting, not a retro.
  
  To run this loop on a schedule (retro on the 1st, weekly refresh Mondays, daily batches via Mode 3), see the creative loops in **marketing-loops**.
  
  ---
  
  ## Failure Modes
  
  - **Roadmapping without a diagnosis** — a slate built before reading the three signals is a wish list; testing without a diagnosis isn't strategy
  - **Iteration-heavy slates in exploration state** — polishing losers while the real problem (angle, offer, audience) goes untested
  - **Ignoring capacity** — the plan the team can't produce at quality is a plan to produce slop
  - **Evidence-free concepts jumping the queue** — the loudest stakeholder's hunch ships as a T3 shoot while tier-2 customer language sits in the icebox
  - **Retro as theater** — winners celebrated, nothing re-ranked, icebox untouched
  - **Scaling-state complacency** — 100% of the slate on winner variations; when the winner fatigues, the pipeline is empty
  

• launch-autopilot/references/marketingskills/ad-creative/references/generative-tools.md23 KB5f09844e93bdupstream ↗

  # Generative AI Tools for Ad Creative
  
  Reference for using AI image generators, video generators, and code-based video tools to produce ad visuals at scale.
  
  ---
  
  ## When to Use Generative Tools
  
  | Need | Tool Category | Best Fit |
  |------|---------------|----------|
  | Static ad images (banners, social) | Image generation | ChatGPT Images 2.0, Nano Banana Pro, Flux, Ideogram |
  | Ad images with text overlays | Image generation (text-capable) | Ideogram, Nano Banana Pro |
  | Short video ads (6-30 sec) | Video generation | Veo, Kling, Runway, Seedance |
  | Video ads with voiceover | Video gen + voice | Veo (native), or Runway + ElevenLabs |
  | Voiceover tracks for ads | Voice generation | ElevenLabs, OpenAI TTS, Cartesia |
  | Multi-language ad versions | Voice generation | ElevenLabs, PlayHT |
  | Brand voice cloning | Voice generation | ElevenLabs, Resemble AI |
  | Product mockups and variations | Image generation + references | Flux (multi-image reference) |
  | Templated video ads at scale | Code-based video | Remotion |
  | Personalized video (name, data) | Code-based video | Remotion |
  | Brand-consistent variations | Image gen + style refs | Flux, Ideogram, Nano Banana Pro |
  
  ---
  
  ## Image Generation
  
  ### Nano Banana Pro (Gemini)
  
  Google DeepMind's image generation model, available through the Gemini API.
  
  **Best for:** High-quality ad images, product visuals, text rendering
  **API:** Gemini API (Google AI Studio, Vertex AI)
  **Pricing:** ~$0.04/image (Gemini 2.5 Flash Image), ~$0.24/4K image (Nano Banana Pro)
  
  **Strengths:**
  - Strong text rendering in images (logos, headlines)
  - Native image editing (modify existing images with prompts)
  - Available through the same Gemini API used for text generation
  - Supports both generation and editing in one model
  
  **Ad creative use cases:**
  - Generate social media ad images from text descriptions
  - Create product mockup variations
  - Edit existing ad images (swap backgrounds, change colors)
  - Generate images with headline text baked in
  
  **API example:**
  ```bash
  # Using the Gemini API for image generation
  curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-image:generateContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
      "contents": [{"parts": [{"text": "Create a clean, modern social media ad image for a project management tool. Show a laptop with a kanban board interface. Bright, professional, 16:9 ratio."}]}],
      "generationConfig": {"responseModalities": ["TEXT", "IMAGE"]}
    }'
  ```
  
  **Docs:** [Gemini Image Generation](https://ai.google.dev/gemini-api/docs/image-generation)
  
  ---
  
  ### Flux (Black Forest Labs)
  
  Open-weight image generation models with API access through Replicate and BFL's native API.
  
  **Best for:** Photorealistic images, brand-consistent variations, multi-reference generation
  **API:** Replicate, BFL API, fal.ai
  **Pricing:** ~$0.01-0.06/image depending on model and resolution
  
  **Model variants:**
  | Model | Speed | Quality | Cost | Best For |
  |-------|-------|---------|------|----------|
  | Flux 2 Pro | ~6 sec | Highest | $0.015/MP | Final production assets |
  | Flux 2 Flex | ~22 sec | High + editing | $0.06/MP | Iterative editing |
  | Flux 2 Dev | ~2.5 sec | Good | $0.012/MP | Rapid prototyping |
  | Flux 2 Klein | Fastest | Good | Lowest | High-volume batch generation |
  
  **Strengths:**
  - Multi-image reference (up to 8 images) for consistent identity across ads
  - Product consistency — same product in different contexts
  - Style transfer from reference images
  - Open-weight Dev model for self-hosting
  
  **Ad creative use cases:**
  - Generate 50+ ad variations with consistent product/person identity
  - Create product-in-context images (your SaaS on different devices)
  - Style-match to existing brand assets using reference images
  - Rapid A/B test image variations
  
  **Docs:** [Replicate Flux](https://replicate.com/black-forest-labs/flux-2-pro), [BFL API](https://docs.bfl.ml/)
  
  ---
  
  ### Ideogram
  
  Specialized in typography and text rendering within images.
  
  **Best for:** Ad banners with text, branded graphics, social ad images with headlines
  **API:** Ideogram API, Runware
  **Pricing:** ~$0.06/image (API), ~$0.009/image (subscription)
  
  **Strengths:**
  - Best-in-class text rendering (~90% accuracy vs ~30% for most tools)
  - Style reference system (upload up to 3 reference images)
  - 4.3 billion style presets for consistent brand aesthetics
  - Strong at logos and branded typography
  
  **Ad creative use cases:**
  - Generate ad banners with headline text directly in the image
  - Create social media graphics with branded text overlays
  - Produce multiple design variations with consistent typography
  - Generate promotional materials without needing a designer for each iteration
  
  **Docs:** [Ideogram API](https://developer.ideogram.ai/), [Ideogram](https://ideogram.ai/)
  
  ---
  
  ### Other Image Tools
  
  | Tool | Best For | API Status | Notes |
  |------|----------|------------|-------|
  | **DALL-E 3** (OpenAI) | General image generation | Official API | Integrated with ChatGPT, good text rendering |
  | **Midjourney** | Artistic, high-aesthetic images | No official public API | Discord-based; unofficial APIs exist but risk bans |
  | **Stable Diffusion** | Self-hosted, customizable | Open source | Best for teams with GPU infrastructure |
  
  ---
  
  ## Video Generation
  
  ### Google Veo
  
  Google DeepMind's video generation model, available through the Gemini API and Vertex AI.
  
  **Best for:** High-quality video ads with native audio, vertical video for social
  **API:** Gemini API, Vertex AI
  **Pricing:** ~$0.15/sec (Veo 3.1 Fast), ~$0.40/sec (Veo 3.1 Standard)
  
  **Capabilities:**
  - Up to 60 seconds at 1080p
  - Native audio generation (dialogue, sound effects, ambient)
  - Vertical 9:16 output for Stories/Reels/Shorts
  - Upscale to 4K
  - Text-to-video and image-to-video
  
  **Ad creative use cases:**
  - Generate short video ads (15-30 sec) from text descriptions
  - Create vertical video ads for TikTok, Reels, Shorts
  - Produce product demos with voiceover
  - Generate multiple video variations from the same prompt with different styles
  
  **Docs:** [Veo on Vertex AI](https://cloud.google.com/vertex-ai/generative-ai/docs/video/overview)
  
  ---
  
  ### Kling (Kuaishou)
  
  Video generation with simultaneous audio-visual generation and camera controls.
  
  **Best for:** Cinematic video ads, longer-form content, audio-synced video
  **API:** Kling API, PiAPI, fal.ai
  **Pricing:** ~$0.09/sec (via fal.ai third-party)
  
  **Capabilities:**
  - Up to 3 minutes at 1080p/30-48fps
  - Simultaneous audio-visual generation (Kling 2.6)
  - Text-to-video and image-to-video
  - Motion and camera controls
  
  **Ad creative use cases:**
  - Longer product explainer videos
  - Cinematic brand videos with synchronized audio
  - Animate product images into video ads
  
  **Docs:** [Kling AI Developer](https://klingai.com/global/dev/model/video)
  
  ---
  
  ### Runway
  
  Video generation and editing platform with strong controllability.
  
  **Best for:** Controlled video generation, style-consistent content, editing existing footage
  **API:** Runway Developer Portal
  
  **Capabilities:**
  - Gen-4: Character/scene consistency across shots
  - Motion brush and camera controls
  - Image-to-video with reference images
  - Video-to-video style transfer
  
  **Ad creative use cases:**
  - Generate video ads with consistent characters/products across scenes
  - Style-transfer existing footage to match brand aesthetics
  - Extend or remix existing video content
  
  **Docs:** [Runway API](https://docs.dev.runwayml.com/)
  
  ---
  
  ### Seedance 2.0 (ByteDance)
  
  ByteDance's video generation model with simultaneous audio-visual generation and multimodal inputs.
  
  **Best for:** Fast, affordable video ads with native audio, multimodal reference inputs
  **API:** BytePlus (official), Replicate, WaveSpeedAI, fal.ai (third-party); OpenAI-compatible API format
  **Pricing:** ~$0.10-0.80/min depending on resolution
  
  **Capabilities:**
  - Up to 20 seconds at up to 2K resolution
  - Simultaneous audio-visual generation (Dual-Branch Diffusion Transformer)
  - Text-to-video and image-to-video
  - Up to 12 reference files for multimodal input
  - OpenAI-compatible API structure
  
  **Ad creative use cases:**
  - High-volume short video ad production at low cost
  - Video ads with synchronized voiceover and sound effects in one pass
  - Multi-reference generation (feed product images, brand assets, style references)
  - Rapid iteration on video ad concepts
  
  **Docs:** [Seedance](https://seed.bytedance.com/en/seedance2_0)
  
  ---
  
  ### Higgsfield
  
  Full-stack video creation platform with cinematic camera controls.
  
  **Best for:** Social video ads, cinematic style, mobile-first content
  **Platform:** [higgsfield.ai](https://higgsfield.ai/)
  
  **Capabilities:**
  - 50+ professional camera movements (zooms, pans, FPV drone shots)
  - Image-to-video animation
  - Built-in editing, transitions, and keyframing
  - All-in-one workflow: image gen, animation, editing
  
  **Ad creative use cases:**
  - Social media video ads with cinematic feel
  - Animate product images into dynamic video
  - Create multiple video variations with different camera styles
  - Quick-turn video content for social campaigns
  
  ---
  
  ### Video Tool Comparison
  
  | Tool | Max Length | Audio | Resolution | API | Best For |
  |------|-----------|-------|------------|-----|----------|
  | **Veo 3.1** | 60 sec | Native | 1080p/4K | Gemini | Vertical social video |
  | **Kling 2.6** | 3 min | Native | 1080p | Third-party | Longer cinematic |
  | **Runway Gen-4** | 10 sec | No | 1080p | Official | Controlled, consistent |
  | **Seedance 2.0** | 20 sec | Native | 2K | Official + third-party | Affordable high-volume |
  | **Higgsfield** | Varies | Yes | 1080p | Web-based | Social, mobile-first |
  
  ---
  
  ## Voice & Audio Generation
  
  For layering realistic voiceovers onto video ads, adding narration to product demos, or generating audio for Remotion-rendered videos. These tools turn ad scripts into natural-sounding voice tracks.
  
  ### When to Use Voice Tools
  
  Many video generators (Veo, Kling, Seedance) now include native audio. Use standalone voice tools when you need:
  
  - **Voiceover on silent video** — Runway Gen-4 and Remotion produce silent output
  - **Brand voice consistency** — Clone a specific voice for all ads
  - **Multi-language versions** — Same ad script in 20+ languages
  - **Script iteration** — Re-record voiceover without reshooting video
  - **Precise control** — Exact timing, emotion, and pacing
  
  ---
  
  ### ElevenLabs
  
  The market leader in realistic voice generation and voice cloning.
  
  **Best for:** Most natural-sounding voiceovers, brand voice cloning, multilingual
  **API:** REST API with streaming support
  **Pricing:** ~$0.12-0.30 per 1,000 characters depending on plan; starts at $5/month
  
  **Capabilities:**
  - 29+ languages with natural accent and intonation
  - Voice cloning from short audio clips (instant) or longer recordings (professional)
  - Emotion and style control
  - Streaming for real-time generation
  - Voice library with hundreds of pre-built voices
  
  **Ad creative use cases:**
  - Generate voiceover tracks for video ads
  - Clone your brand spokesperson's voice for all ad variations
  - Produce the same ad in 10+ languages from one script
  - A/B test different voice styles (authoritative vs. friendly vs. urgent)
  
  **API example:**
  ```bash
  curl -X POST "https://api.elevenlabs.io/v1/text-to-speech/{voice_id}" \
    -H "xi-api-key: $ELEVENLABS_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "text": "Stop wasting hours on manual reporting. Try DataFlow free for 14 days.",
      "model_id": "eleven_multilingual_v2",
      "voice_settings": {"stability": 0.5, "similarity_boost": 0.75}
    }' --output voiceover.mp3
  ```
  
  **Docs:** [ElevenLabs API](https://elevenlabs.io/docs/api-reference/text-to-speech)
  
  ---
  
  ### OpenAI TTS
  
  Simple, affordable text-to-speech built into the OpenAI API.
  
  **Best for:** Quick voiceovers, cost-effective at scale, simple integration
  **API:** OpenAI API (same SDK as GPT/DALL-E)
  **Pricing:** $15/million chars (standard), $30/million chars (HD); ~$0.015/min with gpt-4o-mini-tts
  
  **Capabilities:**
  - 13 built-in voices (no custom cloning)
  - Multiple languages
  - Real-time streaming
  - HD quality option
  - Simple API — same SDK you already use for GPT
  
  **Ad creative use cases:**
  - Fast, cheap voiceover for draft/test ad versions
  - High-volume narration at low cost
  - Prototype ad audio before investing in premium voice
  
  **Docs:** [OpenAI TTS](https://platform.openai.com/docs/guides/text-to-speech)
  
  ---
  
  ### Cartesia Sonic
  
  Ultra-low latency voice generation built for real-time applications.
  
  **Best for:** Real-time voice, lowest latency, emotional expressiveness
  **API:** REST + WebSocket streaming
  **Pricing:** Starts at $5/month; pay-as-you-go from $0.03/min
  
  **Capabilities:**
  - 40ms time-to-first-audio (fastest in class)
  - 15+ languages
  - Nonverbal expressiveness: laughter, breathing, emotional inflections
  - Sonic Turbo for even lower latency
  - Streaming API for real-time generation
  
  **Ad creative use cases:**
  - Real-time ad preview during creative iteration
  - Interactive demo videos with dynamic narration
  - Ads requiring natural laughter, sighs, or emotional reactions
  
  **Docs:** [Cartesia Sonic](https://docs.cartesia.ai/build-with-cartesia/tts-models/latest)
  
  ---
  
  ### Voicebox (Open Source)
  
  Free, local-first voice synthesis studio powered by Qwen3-TTS. The open-source alternative to ElevenLabs.
  
  **Best for:** Free voice cloning, local/private generation, zero-cost batch production
  **API:** Local REST API at `http://localhost:8000`
  **Pricing:** Free (MIT license). Runs entirely on your machine.
  **Stack:** Tauri (Rust) + React + FastAPI (Python)
  
  **Capabilities:**
  - Voice cloning from short audio samples via Qwen3-TTS
  - Multi-language support (English, Chinese, more planned)
  - Multi-track timeline editor for composing conversations
  - 4-5x faster inference on Apple Silicon via MLX Metal acceleration
  - Local REST API for programmatic generation
  - No cloud dependency — all processing on-device
  
  **Ad creative use cases:**
  - Free voice cloning for brand spokesperson across all ad variations
  - Batch generate voiceovers without per-character costs
  - Private/local generation when ad content is sensitive or pre-launch
  - Prototype voice variations before committing to a paid service
  
  **API example:**
  ```bash
  curl -X POST http://localhost:8000/generate \
    -H "Content-Type: application/json" \
    -d '{"text": "Stop wasting hours on manual reporting.", "profile_id": "abc123", "language": "en"}'
  ```
  
  **Install:** Desktop apps for macOS and Windows at [voicebox.sh](https://voicebox.sh), or build from source:
  ```bash
  git clone https://github.com/jamiepine/voicebox.git
  cd voicebox && make setup && make dev
  ```
  
  **Docs:** [GitHub](https://github.com/jamiepine/voicebox)
  
  ---
  
  ### Other Voice Tools
  
  | Tool | Best For | Differentiator | API |
  |------|----------|---------------|-----|
  | **PlayHT** | Large voice library, low latency | 900+ voices, <300ms latency, ultra-realistic | [play.ht](https://play.ht/) |
  | **Resemble AI** | Enterprise voice cloning | On-premise deployment, real-time speech-to-speech | [resemble.ai](https://www.resemble.ai/) |
  | **WellSaid Labs** | Ethical, commercial-safe voices | Voices from compensated actors, safe for commercial use | [wellsaid.io](https://www.wellsaid.io/) |
  | **Fish Audio** | Budget-friendly, emotion control | ~50-70% cheaper than ElevenLabs, emotion tags | [fish.audio](https://fish.audio/) |
  | **Murf AI** | Non-technical teams | Browser-based studio, 200+ voices | [murf.ai](https://murf.ai/) |
  | **Google Cloud TTS** | Google ecosystem, scale | 220+ voices, 40+ languages, enterprise SLAs | [Google TTS](https://cloud.google.com/text-to-speech) |
  | **Amazon Polly** | AWS ecosystem, cost | Neural voices, SSML control, cheap at volume | [Amazon Polly](https://aws.amazon.com/polly/) |
  
  ---
  
  ### Voice Tool Comparison
  
  | Tool | Quality | Cloning | Languages | Latency | Price/1K chars |
  |------|---------|---------|-----------|---------|----------------|
  | **ElevenLabs** | Best | Yes (instant + pro) | 29+ | ~200ms | $0.12-0.30 |
  | **OpenAI TTS** | Good | No | 13+ | ~300ms | $0.015-0.030 |
  | **Cartesia Sonic** | Very good | No | 15+ | ~40ms | ~$0.03/min |
  | **PlayHT** | Very good | Yes | 140+ | <300ms | ~$0.10-0.20 |
  | **Fish Audio** | Good | Yes | 13+ | ~200ms | ~$0.05-0.10 |
  | **WellSaid** | Very good | No (actor voices) | English | ~300ms | Custom pricing |
  | **Voicebox** | Good | Yes (local) | 2+ | Local | Free (open source) |
  
  ### Choosing a Voice Tool
  
  ```
  Need voiceover for ads?
  ├── Need to clone a specific brand voice?
  │   ├── Best quality → ElevenLabs
  │   ├── Enterprise/on-premise → Resemble AI
  │   └── Budget-friendly → Fish Audio, PlayHT
  ├── Need multilingual (same ad, many languages)?
  │   ├── Most languages → PlayHT (140+)
  │   └── Best quality → ElevenLabs (29+)
  ├── Need free / open source / local?
  │   └── Voicebox (MIT, runs on your machine)
  ├── Need cheap, fast, good-enough?
  │   └── OpenAI TTS ($0.015/min)
  ├── Need commercially-safe licensing?
  │   └── WellSaid Labs (actor-compensated voices)
  └── Need real-time/interactive?
      └── Cartesia Sonic (40ms TTFA)
  ```
  
  ### Workflow: Voice + Video
  
  ```
  1. Write ad script (use ad-creative skill for copy)
  2. Generate voiceover with ElevenLabs/OpenAI TTS
  3. Generate or render video:
     a. Silent video from Runway/Remotion → layer voice track
     b. Or use Veo/Seedance with native audio (skip separate VO)
  4. Combine with ffmpeg if layering separately:
     ffmpeg -i video.mp4 -i voiceover.mp3 -c:v copy -c:a aac output.mp4
  5. Generate variations (different scripts, voices, or languages)
  ```
  
  ---
  
  ## Code-Based Video: Remotion
  
  For templated, data-driven video ads at scale, Remotion is the best option. Unlike AI video generators that produce unique video from prompts, Remotion uses React code to render deterministic, brand-perfect video from templates and data.
  
  **Best for:** Templated ad variations, personalized video, brand-consistent production
  **Stack:** React + TypeScript
  **Pricing:** Free for individuals/small teams; commercial license required for 4+ employees
  **Docs:** [remotion.dev](https://www.remotion.dev/)
  
  ### Why Remotion for Ads
  
  | AI Video Generators | Remotion |
  |---------------------|----------|
  | Unique output each time | Deterministic, pixel-perfect |
  | Prompt-based, less control | Full code control over every frame |
  | Hard to match brand exactly | Exact brand colors, fonts, spacing |
  | One-at-a-time generation | Batch render hundreds from data |
  | No dynamic data insertion | Personalize with names, prices, stats |
  
  ### Ad Creative Use Cases
  
  **1. Dynamic product ads**
  Feed a JSON array of products and render a unique video ad for each:
  ```tsx
  // Simplified Remotion component for product ads
  export const ProductAd: React.FC<{
    productName: string;
    price: string;
    imageUrl: string;
    tagline: string;
  }> = ({productName, price, imageUrl, tagline}) => {
    return (
      <AbsoluteFill style={{backgroundColor: '#fff'}}>
        <Img src={imageUrl} style={{width: 400, height: 400}} />
        <h1>{productName}</h1>
        <p>{tagline}</p>
        <div className="price">{price}</div>
        <div className="cta">Shop Now</div>
      </AbsoluteFill>
    );
  };
  ```
  
  **2. A/B test video variations**
  Render the same template with different headlines, CTAs, or color schemes:
  ```tsx
  const variations = [
    {headline: "Save 50% Today", cta: "Get the Deal", theme: "urgent"},
    {headline: "Join 10K+ Teams", cta: "Start Free", theme: "social-proof"},
    {headline: "Built for Speed", cta: "Try It Now", theme: "benefit"},
  ];
  // Render all variations programmatically
  ```
  
  **3. Personalized outreach videos**
  Generate videos addressing prospects by name for cold outreach or sales.
  
  **4. Social ad batch production**
  Render the same content across different aspect ratios:
  - 1:1 for feed
  - 9:16 for Stories/Reels
  - 16:9 for YouTube
  
  ### Remotion Workflow for Ad Creative
  
  ```
  1. Design template in React (or use AI to generate the component)
  2. Define data schema (products, headlines, CTAs, images)
  3. Feed data array into template
  4. Batch render all variations
  5. Upload to ad platform
  ```
  
  ### Getting Started
  
  ```bash
  # Create a new Remotion project
  npx create-video@latest
  
  # Render a single video
  npx remotion render src/index.ts MyComposition out/video.mp4
  
  # Batch render from data
  npx remotion render src/index.ts MyComposition --props='{"data": [...]}'
  ```
  
  ---
  
  ## Choosing the Right Tool
  
  ### Decision Tree
  
  ```
  Need video ads?
  ├── Templated, data-driven (same structure, different data)
  │   └── Use Remotion
  ├── Unique creative from prompts (exploratory)
  │   ├── Need dialogue/voiceover? → Veo 3.1, Kling 2.6, Seedance 2.0
  │   ├── Need consistency across scenes? → Runway Gen-4
  │   ├── Need vertical social video? → Veo 3.1 (native 9:16)
  │   ├── Need high volume at low cost? → Seedance 2.0
  │   └── Need cinematic camera work? → Higgsfield, Kling
  └── Both → Use AI gen for hero creative, Remotion for variations
  
  Need image ads?
  ├── Need text/headlines in image? → Ideogram
  ├── Need product consistency across variations? → Flux (multi-ref)
  ├── Need quick iterations on existing images? → Nano Banana Pro
  ├── Need highest visual quality? → Flux Pro, Midjourney
  └── Need high volume at low cost? → Flux Klein, Nano Banana
  ```
  
  ### Cost Comparison for 100 Ad Variations
  
  | Approach | Tool | Approximate Cost |
  |----------|------|-----------------|
  | 100 static images | Nano Banana Pro | ~$4-24 |
  | 100 static images | Flux Dev | ~$1-2 |
  | 100 static images | Ideogram API | ~$6 |
  | 100 × 15-sec videos | Veo 3.1 Fast | ~$225 |
  | 100 × 15-sec videos | Remotion (templated) | ~$0 (self-hosted render) |
  | 10 hero videos + 90 templated | Veo + Remotion | ~$22 + render time |
  
  ### Recommended Workflow for Scaled Ad Production
  
  1. **Generate hero creative** with AI (Nano Banana, Flux, Veo) — high-quality, exploratory
  2. **Build templates** in Remotion based on winning creative patterns
  3. **Batch produce variations** with Remotion using data (products, headlines, CTAs)
  4. **Iterate** — use AI tools for new angles, Remotion for scale
  
  This hybrid approach gives you the creative exploration of AI generators and the consistency and scale of code-based rendering.
  
  ---
  
  ## Platform-Specific Image Specs
  
  When generating images for ads, request the correct dimensions:
  
  | Platform | Placement | Aspect Ratio | Recommended Size |
  |----------|-----------|-------------|-----------------|
  | Meta Feed | Single image | 1:1 | 1080x1080 |
  | Meta Stories/Reels | Vertical | 9:16 | 1080x1920 |
  | Meta Carousel | Square | 1:1 | 1080x1080 |
  | Google Display | Landscape | 1.91:1 | 1200x628 |
  | Google Display | Square | 1:1 | 1200x1200 |
  | LinkedIn Feed | Landscape | 1.91:1 | 1200x627 |
  | LinkedIn Feed | Square | 1:1 | 1200x1200 |
  | TikTok Feed | Vertical | 9:16 | 1080x1920 |
  | Twitter/X Feed | Landscape | 16:9 | 1200x675 |
  | Twitter/X Card | Landscape | 1.91:1 | 800x418 |
  
  Include these dimensions in your generation prompts to avoid needing to crop or resize.
  

• launch-autopilot/references/marketingskills/ad-creative/references/hook-system.md9.8 KBd1f01ae99cfcupstream ↗

  # The Hook System
  
  The first three seconds decide whether the rest of the ad exists. Hooks are the highest-leverage unit of paid creative work — and hook *diversity* is what earns incremental learning: distinct hooks reach distinct pockets of the audience, while near-identical openings mostly re-test what you already know about the same one. This reference is a complete system for generating, diagnosing, and iterating hooks — not a list of one-liners.
  
  Use it inside Mode 1/3 generation (hooks for new concepts), Mode 2 iteration (diagnosing why an ad underperforms), and the creative strategy loop in [creative-roadmap.md](creative-roadmap.md).
  
  ---
  
  ## A Hook Is Three Components, Not a Line
  
  In video, the hook is the simultaneous combination of:
  
  | Component | What it is | Job |
  |---|---|---|
  | **Visual action** | What is literally happening on screen in seconds 0–3 | Stop the thumb |
  | **Spoken line** | The first words of VO or dialogue | Open the loop |
  | **Caption text** | On-screen header/overlay text | Anchor the claim for sound-off viewers |
  
  **The no-duplication rule:** the three components must complement, never repeat. If the VO says "I stopped paying $200/mo for my gym" while the caption reads "I stopped paying $200/mo" over a static talking head, two of the three slots are wasted. Strong hooks split the work — visual shows the cancellation email, VO says the line, caption names the alternative. When writing hooks, write all three columns explicitly; a hook spec with one column filled in is a third of a hook.
  
  Static ads collapse this to two components (visual + headline) — the same rule applies: the headline must not caption the image.
  
  ---
  
  ## The Generation Pipeline
  
  Work top-down; hooks written without the upstream steps read like everyone else's ads.
  
  ```
  Segment → Motivation → Format → Hook (three components)
  ```
  
  1. **Segment** — which specific buyer this hook addresses. Not the whole ICP: a slice with a shared situation (from the Grounded Inputs corpus: reviews, comments, sales-call language). The narrower the segment, the sharper the hook.
  2. **Motivation** — the single pain, desire, or objection that moves this segment, in *their* words. Pull verbatim phrases from reviews and comments; the corpus language always outperforms marketing paraphrase.
  3. **Format** — the delivery vehicle: street interview, POV selfie, screen recording, unboxing, side-by-side demo, text-on-screen static, founder-to-camera, reaction stitch. Pick the format *before* writing the line — the same motivation reads completely differently as a street-interview answer vs. a confession-to-camera.
  4. **Hook** — now write the three components for this segment × motivation × format cell.
  
  **Output as a hook matrix** so coverage is visible:
  
  ```
  | # | Segment | Motivation (verbatim source) | Format | Visual action | Spoken line | Caption |
  ```
  
  Generate across the matrix, not down a single column — ten hooks for ten segment×motivation cells beat thirty rewordings of one cell. This is the same angle-diversity principle as the static template library: matrix diversity is audience diversity.
  
  ---
  
  ## Hook Opening Moves
  
  A menu of proven opening structures. Cycle through them like the static templates — don't cluster on favorites:
  
  | Move | Shape | Watch out |
  |---|---|---|
  | **Curiosity gap** | Withhold the noun: "The ingredient behind most 3pm crashes" | Must pay off within the ad or it's clickbait that poisons CVR |
  | **Bold claim** | A specific, falsifiable statement: "This replaced my entire morning routine" | Needs substantiation on screen or in the on-ramp |
  | **First-person confession** | "I was doing [common thing] completely wrong" | Reads fake without lived-in detail |
  | **Contrast / before-after** | Two states shown or named in the first beat | The transformation must be visually honest — see compliance notes in SKILL.md |
  | **Relatability / POV** | Mirror a hyper-specific situation: "POV: it's 3pm and you're on your fourth coffee" | Specificity is the entire mechanic; generic POV is invisible |
  | **Question** | Ask the exact question the buyer types into search or ChatGPT | Use their phrasing verbatim from the corpus |
  | **Countdown / gamified** | A timer or on-screen challenge that promises a payoff at the end | Payoff must exist; hold-rate collapses on cheats |
  | **Proof-first** | Lead with the receipt — the result screenshot, the stat, the demo money-shot | Strongest when the proof brags by itself |
  | **Choice** | Put two options in front of the viewer: "Sandler or MEDDIC for a $50K deal?" | Both options must be real ones the audience weighs; viewers who know both stay to see who wins, viewers who know neither stay to learn |
  | **Old vs. new** | "We used to take elixirs. Now everyone drinks prebiotic soda. Which is better for your gut?" | Answer the question from expertise; the hook only works if the payoff takes a side |
  | **Us vs. them** | "Most [role]s do X. The ones who [result] do Y." | Name a behavior the audience will recognize as what "most" people really do |
  | **False assumption** | Challenge something the buyer believes they need: "You can cancel ClickFunnels" | Draws the strongest reactions, including angry ones; keep the body fair to the named product, and get legal review before naming a competitor in paid ads |
  | **Declaration, then question** | State what the audience already agrees with, then doubt it: "You need to spend $20K a month recruiting on Indeed. Or do you?" | The doubt needs a real answer in the body; still being tested by the practitioners who shared it (October 2026) |
  
  The last five are one family: **contrast**. People understand a thing by comparing it with something else, so a hook that sets up two states, two options, or two groups gives the viewer a question to stay for. That is also why AI copy leans on "it's not X, it's Y." The difference is that a good contrast hook compares two things the audience actually weighs, while the AI tell negates a claim nobody made (see the copywriting skill's AI-tells reference). Contrast hooks work best for educational content and decisions; for impulse products, lead with proof or POV instead.
  
  ---
  
  ## The Diagnostic Funnel
  
  Each metric in the delivery funnel isolates a different component. When an ad underperforms, read the funnel to find *which part* to fix instead of scrapping the whole ad:
  
  | Stage | Metric | If it's weak, the problem is | Fix |
  |---|---|---|---|
  | Stop | Thumbstop / 3-sec view rate | **Visual action** (and caption) | New visual opening; same everything else |
  | Stay | Hold rate (3s → 15s / 50% view) | **The on-ramp** — what follows the hook | Rework seconds 3–15, not the hook |
  | Click | CTR | Desire/offer clarity mid-ad | Sharpen the promise, CTA, or proof |
  | Convert | CVR post-click | Congruence — the page doesn't continue the ad | Fix the landing page or the claim, per **cro** |
  
  Two rules this table enforces:
  
  - **A great thumbstop is not a great ad.** A clickbait visual that attracts the wrong viewers shows up as high thumbstop + collapsed hold/CVR. Read the whole funnel before declaring a winning hook.
  - **One component per iteration.** Change the visual OR the on-ramp OR the offer framing per test cycle — matching the one-variable rule in Common Mistakes.
  
  ---
  
  ## The On-Ramp Rule
  
  The on-ramp is seconds ~3–15: the bridge from hook to body. **A good on-ramp logically extends the hook's premise; a bad one pivots to a product pitch that abandons it.** If the hook promises "what actually causes this," the next beat must start explaining the cause — not introduce the brand story.
  
  Corollary: **every hook test is also an on-ramp test.** Swapping a new hook onto an existing ad body usually breaks the premise-bridge; when testing hooks, re-write the on-ramp to match each one. Hold rate is the on-ramp's metric — diagnose it separately from thumbstop.
  
  ---
  
  ## Fidelity Laddering
  
  Match production cost to evidence strength (production tiers are defined in [creative-roadmap.md](creative-roadmap.md)):
  
  - **Hunches ship low-fidelity within a day or two:** statics, text-on-screen video, voiceover-over-b-roll, remixes of existing footage. The goal is a cheap signal on the *angle*, not a polished ad.
  - **Validated angles earn high-fidelity:** creator shoots, street interviews, staged demos. Only spend production budget on hooks whose low-fi version already showed a funnel signal (even a single-metric win — a hold-rate spike on an ugly static is evidence).
  
  Testing a hunch with an expensive shoot and testing a proven angle with a throwaway static are both mistakes — the ladder runs in one direction.
  
  ---
  
  ## Grounding Rules (inherited, non-negotiable)
  
  Hooks inherit every grounding rule from SKILL.md: every hook cites the corpus source its motivation came from; no invented claims, stats, or testimonials; verbatim customer language over paraphrase. Additionally, mine **organic content in the niche** (top-performing TikToks/Reels/posts, via the **scraping** skill or the social listening tooling in **social**) for the audience's actual vocabulary — the words the niche uses ("GLP-1" vs. the clinical term, the slang for the pain) belong in the caption and spoken line. Organic mining is language research, not copying: take the vocabulary and the visual conventions, never a creator's specific creative.
  
  ---
  
  ## Common Failure Modes
  
  - **Thirty rewordings of one cell** — variation without matrix coverage; diversity of segment×motivation is the point
  - **Components duplicating each other** — three slots saying one thing
  - **Hook tested, on-ramp inherited** — premise-bridge broken, hold rate blamed on the hook
  - **Funnel read stops at thumbstop** — clickbait winners scale into CVR craters
  - **Polished hunches** — high-fidelity production spent on unvalidated angles
  - **Marketing-voice captions** — the corpus and the niche's organic content define the vocabulary; "revolutionary formula" appears in neither
  

• launch-autopilot/references/marketingskills/ad-creative/references/imessage-video-ads.md19 KB866b38942eabupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/ad-creative/references/meta-creative-formats.md10 KB8808ea60d055upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/ad-creative/references/motion-video-ads.md12 KBfab0ef4d47daupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/ad-creative/references/platform-specs.md6.4 KBc9a3c4a53465upstream ↗

  # Platform Specs Reference
  
  Complete character limits, format requirements, and best practices for each ad platform.
  
  ---
  
  ## Google Ads
  
  ### Responsive Search Ads (RSAs)
  
  | Element | Character Limit | Required | Notes |
  |---------|----------------|----------|-------|
  | Headline | 30 chars | 3 minimum, 15 max | Any 3 may be shown together |
  | Description | 90 chars | 2 minimum, 4 max | Any 2 may be shown together |
  | Display path 1 | 15 chars | Optional | Appears after domain in URL |
  | Display path 2 | 15 chars | Optional | Appears after path 1 |
  | Final URL | No limit | Required | Landing page URL |
  
  **Combination rules:**
  - Google selects up to 3 headlines and 2 descriptions to show
  - Headlines appear separated by " | " or stacked
  - Any headline can appear in any position unless pinned
  - Pinning reduces Google's ability to optimize — use sparingly
  
  **Pinning strategy:**
  - Pin your brand name to position 1 if brand guidelines require it
  - Pin your strongest CTA to position 2 or 3
  - Leave most headlines unpinned for machine learning
  
  **Headline mix recommendation (15 headlines):**
  - 3-4 keyword-focused (match search intent)
  - 3-4 benefit-focused (what they get)
  - 2-3 social proof (numbers, awards, customers)
  - 2-3 CTA-focused (action to take)
  - 1-2 differentiators (why you over competitors)
  - 1 brand name headline
  
  **Description mix recommendation (4 descriptions):**
  - 1 benefit + proof point
  - 1 feature + outcome
  - 1 social proof + CTA
  - 1 urgency/offer + CTA (if applicable)
  
  ### Performance Max
  
  | Element | Character Limit | Notes |
  |---------|----------------|-------|
  | Headline | 30 chars (5 required) | Short headlines for various placements |
  | Long headline | 90 chars (5 required) | Used in display, video, discover |
  | Description | 90 chars (1 required, 5 max) | Accompany various ad formats |
  | Business name | 25 chars | Required |
  
  ### Display Ads
  
  | Element | Character Limit |
  |---------|----------------|
  | Headline | 30 chars |
  | Long headline | 90 chars |
  | Description | 90 chars |
  | Business name | 25 chars |
  
  ---
  
  ## Meta Ads (Facebook & Instagram)
  
  ### Single Image / Video / Carousel
  
  | Element | Recommended | Maximum | Notes |
  |---------|-------------|---------|-------|
  | Primary text | 125 chars | 2,200 chars | Text above image; truncated after ~125 |
  | Headline | 40 chars | 255 chars | Below image; truncated after ~40 |
  | Description | 30 chars | 255 chars | Below headline; may not show |
  | URL display link | 40 chars | N/A | Optional custom display URL |
  
  **Placement-specific notes:**
  - **Feed**: All elements show; primary text most visible
  - **Stories/Reels**: Primary text overlaid; keep under 72 chars
  - **Right column**: Only headline visible; skip description
  - **Audience Network**: Varies by publisher
  
  **Best practices:**
  - Front-load the hook in primary text (first 125 chars)
  - Use line breaks for readability in longer primary text
  - Emojis: test, but don't overuse — 1-2 per ad max
  - Questions in primary text increase engagement
  - Headline should be a clear CTA or value statement
  
  ### Lead Ads (Instant Form)
  
  | Element | Limit |
  |---------|-------|
  | Greeting headline | 60 chars |
  | Greeting description | 360 chars |
  | Privacy policy text | 200 chars |
  
  ---
  
  ## LinkedIn Ads
  
  ### Single Image Ad
  
  | Element | Recommended | Maximum | Notes |
  |---------|-------------|---------|-------|
  | Intro text | 150 chars | 600 chars | Above the image; truncated after ~150 |
  | Headline | 70 chars | 200 chars | Below the image |
  | Description | 100 chars | 300 chars | Only shows on Audience Network |
  
  ### Carousel Ad
  
  | Element | Limit |
  |---------|-------|
  | Intro text | 255 chars |
  | Card headline | 45 chars |
  | Card count | 2-10 cards |
  
  ### Message Ad (InMail)
  
  | Element | Limit |
  |---------|-------|
  | Subject line | 60 chars |
  | Message body | 1,500 chars |
  | CTA button | 20 chars |
  
  ### Text Ad
  
  | Element | Limit |
  |---------|-------|
  | Headline | 25 chars |
  | Description | 75 chars |
  
  **LinkedIn-specific guidelines:**
  - Professional tone, but not boring
  - Use job-specific language the audience recognizes
  - Statistics and data points perform well
  - Avoid consumer-style hype ("Amazing!" "Incredible!")
  - First-person testimonials from peers resonate
  
  ---
  
  ## TikTok Ads
  
  ### In-Feed Ads
  
  | Element | Recommended | Maximum | Notes |
  |---------|-------------|---------|-------|
  | Ad text | 80 chars | 100 chars | Above the video |
  | Display name | N/A | 40 chars | Brand name |
  | CTA button | Platform options | Predefined | Select from TikTok's options |
  
  ### Spark Ads (Boosted Organic)
  
  | Element | Notes |
  |---------|-------|
  | Caption | Uses original post caption |
  | CTA button | Added by advertiser |
  | Display name | Original creator's handle |
  
  **TikTok-specific guidelines:**
  - Native content outperforms polished ads
  - First 2 seconds determine if they watch
  - Use trending sounds and formats
  - Text overlay is essential (most watch with sound off)
  - Vertical video only (9:16)
  
  ---
  
  ## Twitter/X Ads
  
  ### Promoted Tweets
  
  | Element | Limit | Notes |
  |---------|-------|-------|
  | Tweet text | 280 chars | Full tweet with image/video |
  | Card headline | 70 chars | Website card |
  | Card description | 200 chars | Website card |
  
  ### Website Cards
  
  | Element | Limit |
  |---------|-------|
  | Headline | 70 chars |
  | Description | 200 chars |
  
  **Twitter/X-specific guidelines:**
  - Conversational, casual tone
  - Short sentences work best
  - One clear message per tweet
  - Hashtags: 1-2 max (0 is often better for ads)
  - Threads can work for consideration-stage content
  
  ---
  
  ## Character Counting Tips
  
  - **Spaces count** as characters on all platforms
  - **Emojis** count as 1-2 characters depending on platform
  - **Special characters** (|, &, etc.) count as 1 character
  - **URLs** in body text count against limits
  - **Dynamic keyword insertion** (`{KeyWord:default}`) can exceed limits — set safe defaults
  - Always verify in the platform's ad preview before launching
  
  ---
  
  ## Multi-Platform Creative Adaptation
  
  When creating for multiple platforms simultaneously, start with the most restrictive format:
  
  1. **Google Search headlines** (30 chars) — forces the tightest messaging
  2. **Expand to Meta headlines** (40 chars) — add a word or two
  3. **Expand to LinkedIn intro text** (150 chars) — add context and proof
  4. **Expand to Meta primary text** (125+ chars) — full hook and value prop
  
  This cascading approach ensures your core message works everywhere, then gets enriched for platforms that allow more space.
  

• launch-autopilot/references/marketingskills/ad-creative/references/short-form-video-specs.md19 KB5bde8b97a72bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/ad-creative/references/static-ad-templates.md23 KB271b342b7d12upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/aso/GUIDE.md16 KB71a6b23cc90bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/aso/references/apple-specs.md5.9 KB1a34d7fa71aeupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/aso/references/benchmarks.md5.3 KB9e11a85557f0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/aso/references/google-play-specs.md6.4 KBf733ef652ee2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/aso/references/report-template.md5.0 KB68ad47716205upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/aso/references/scoring-criteria.md13 KBad9730ac4139upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/community-marketing/GUIDE.md9.6 KB441463df2bd0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/community-marketing/references/community-models.md4.0 KB6844946a1a3aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/content-strategy/GUIDE.md19 KB89b4b6323fb4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/content-strategy/references/content-distribution.md5.4 KB6f4a3c38a15eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/content-strategy/references/headless-cms.md8.4 KBfa01433bf3b2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/copywriting/GUIDE.md15 KBe70bd2e1f4e9upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/copywriting/references/ai-tells.md20 KB0a93ab3b88fcupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/copywriting/references/copy-frameworks.md14 KB194aefed131cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/copywriting/references/natural-transitions.md5.4 KB5fba31a5d3bfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/directory-submissions/GUIDE.md26 KB426cf243215cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/directory-submissions/references/directory-list.md32 KB6c57ba30ea66upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/directory-submissions/references/positioning-variations.md9.2 KBa5dd53019633upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/directory-submissions/references/submission-tracker-template.csv20 KB88996b7e7eb9upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/emails/GUIDE.md11 KBe660baf4adf7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/emails/references/copy-guidelines.md2.3 KB6e31f2b5cc33upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/emails/references/email-types.md14 KBdd6124051517upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/emails/references/sequence-templates.md3.8 KB6146dd36af02upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/image/GUIDE.md16 KB91126652af09upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/image/references/ai-image-prompting.md8.0 KB798f1836cec7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/launch/GUIDE.md15 KBb7783f50953cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/launch/references/shipped-changes.md4.6 KB321e5715b16cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/launch/references/site-launch-qa.md3.7 KB07e7f3e28ba3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/LICENSE1.0 KB7c48dd638a9eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/marketing-loops/GUIDE.md9.7 KB9c85e3a3cdb4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/marketing-loops/references/loop-catalog.md63 KB794202cc3a35upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/marketing-loops/references/loop-guardrails.md4.9 KB9c26ebc920adupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/marketing-loops/references/loop-orchestration.md5.2 KB778c03718ccdupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/marketing-loops/references/loop-state.md5.7 KBd41876f6e9a7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/marketing-loops/references/loop-template.md5.0 KB757e22db0f77upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/marketing-psychology/GUIDE.md21 KB806c09fba822upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/product-marketing/GUIDE.md14 KB3af463a602aaupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/product-marketing/references/brand-voice.md8.2 KB697bc73db156upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/public-relations/GUIDE.md9.4 KB70e95520d606upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/public-relations/references/crisis-communications.md8.4 KBf99b4cb87b4eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/public-relations/references/journalist-pitching.md11 KBeb27b02f68f3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/public-relations/references/media-outlets.md9.1 KB6bc8f801b246upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/public-relations/references/newsjacking.md8.4 KBabd2315996a1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/public-relations/references/podcast-guest-prep.md5.5 KB33b7d30de6e0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/public-relations/references/press-platforms.md6.7 KB4ef510f8e561upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/public-relations/references/statement-templates.md5.5 KB8d1fe844ae1dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/public-relations/references/story-angles.md6.4 KB13f0b3bef147upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/social/GUIDE.md18 KB602451c83630upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/social/references/carousel-frameworks.md11 KB76c65c3d34dfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/social/references/listening-sources-template.md3.4 KB286ca03a013dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/social/references/listening.md13 KB0b3569a5ff4fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/social/references/platform-limits.md2.8 KB94e1df9f2212upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/social/references/platforms.md8.1 KBbbf7b9b6277fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/social/references/post-templates.md3.9 KB10be33fe2104upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/social/references/reverse-engineering.md5.4 KB6d6b8f9d8a49upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/social/references/short-form-video.md6.9 KB477fc35b68ddupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/social/references/x-algorithm.md6.9 KBaf6aef741f89upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/SOURCE_COMMIT52 Bb41961cbd7eeupstream ↗

  365b412152b9542499ca1439426f7fc3cc92bb65 2026-10-15
  

• launch-autopilot/references/marketingskills/video/GUIDE.md15 KB7838d983f1eaupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/video/references/ai-video-prompting.md5.1 KB3fc3a19c33b2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/video/references/edit-anatomy.md7.4 KB301212d82fd2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/marketingskills/video/references/product-demo-recording.md10 KBad5fb6da35a7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/references/strategy.md6.2 KBe555c3e5a565upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/assets/templates/_brand.example.json437 Bf0fdb42ee42cupstream ↗

  {
    "name": "Acme Notes",
    "url": "acmenotes.app",
    "bg": "#0f1115", "fg": "#f5f5f0", "muted": "#9aa0a6", "accent": "#ff6a3d", "accent2": "#3dd6ff",
    "font_head": "Space Grotesk", "font_head_q": "Space+Grotesk",
    "font_body": "Inter", "font_body_q": "Inter",
    "logo": "",
    "_note": "Colors/fonts come from the product's CSS or design tokens. logo = path or data: URI, \"\" hides it. *_q = Google Fonts query form (spaces -> +)."
  }
  

• launch-autopilot/assets/templates/carousel-slide.html1.7 KB53aae09c1e63upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/assets/templates/og-image.html1.3 KBed403dc31749upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/assets/templates/poster.html2.0 KBe03f06f3fbefupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/assets/templates/social-post.html1.8 KBe30dfb30273eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/assets/templates/story-scene.html1.8 KBb551f176d967upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• launch-autopilot/NOTICE.md553 B404acf05b59fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• README.mdupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/andreas-ships-launch-autopilot-launch-autopilot.md