Skip to content
Back to search

ucsandman

MarketplaceWorks with Claude CodeGitHub

Create product launch assets with Remotion, then review and distribute them through guarded, dry-run-first workflows.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked yesterday

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/ucsandman/marketing-studio with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/ucsandman/marketing-studio'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ucsandman--marketing-studio/badge.svg)](/listings/ucsandman--marketing-studio)

HTML

<a href="/listings/ucsandman--marketing-studio"><img src="/api/listings/ucsandman--marketing-studio/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

As a Claude Code plugin

/plugin marketplace add ucsandman/marketing-studio
/plugin install marketing-studio@ucsandman

Plugin skills are namespaced, so the commands are `/marketing-studio:marketing`, `/marketing-studio:logo-reveal`, and so on.

The plugin manifests declare version **2.0.0**. Migrating from 1.x requires a product repository for every production run: pass `--project <product-repo>` (or invoke a supported tool from that product worktree). Generated inputs and outputs no longer default to the installed engine or its legacy `out/` tree. See the [changelog](CHANGELOG.md) for the release status and migration notes.

The engine ships with the plugin, but its npm dependencies do not. Bootstrap once by asking Claude to *"bootstrap the marketing studio engine"*, or run it yourself against the installed plugin directory:

$pluginDir = "C:\path\to\marketing-studio"
python "$pluginDir\launch.py" --bootstrap
npm --prefix "$pluginDir\feeders\diagram" install
npm --prefix "$pluginDir\launch" install
npm --prefix "$pluginDir\launch" run build

The bootstrap command installs the studio and capture-feeder dependencies and then prints a toolchain report. The two npm commands install the separate diagram and distribution packages. Replace `$pluginDir` with the installed plugin directory. Copy `.env.example` to `.env` there if you have a Blender path or an ElevenLabs key.

From source

git clone git@github.com:ucsandman/marketing-studio.git
cd marketing-studio
python launch.py --bootstrap    # installs studio + capture deps, then checks the toolchain
npm --prefix feeders/diagram ci # optional diagram feeder
npm --prefix launch ci          # distribution CLI + dashboard
npm --prefix launch run build
cp .env.example .env            # set BLENDER_PATH / ELEVENLABS_API_KEY if you have them
node scripts/install-skills.mjs # installs /marketing and friends into ~/.claude/skills

The included installer puts unnamespaced commands in `~/.claude/skills` (`/marketing` rather than `/marketing-studio:marketing`). Renderer source stays in the clone; production inputs and outputs still belong to the selected product repository. Other agent hosts can run the engine commands directly, but need their own compatible skill installation layer.

Then, from your product's repo:

claude
> /marketing

The agent asks one batched round of questions (brand, destination, audio, platforms, checkpoint mode) and runs the whole pipeline. If your brand is new, it derives tokens from your repo's design system (DESIGN.md, Tailwind config, CSS variables) and only asks for what it cannot infer.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 31 lines
  1. {
  2. "name": "ucsandman",
  3. "owner": {
  4. "name": "Wes Sander",
  5. "url": "https://github.com/ucsandman"
  6. },
  7. "metadata": {
  8. "description": "Plugins by ucsandman."
  9. },
  10. "plugins": [
  11. {
  12. "name": "marketing-studio",
  13. "description": "Turn a product into a full marketing asset suite (logo reveal, product demo, launch video with generated audio, social clips, OG images) and then launch it: domain, payments, comms, and multi-platform posting with the videos attached, dry-run by default. Rendered locally through Remotion.",
  14. "version": "2.0.0",
  15. "author": {
  16. "name": "Wes Sander",
  17. "url": "https://github.com/ucsandman"
  18. },
  19. "source": "./",
  20. "category": "productivity",
  21. "homepage": "https://github.com/ucsandman/marketing-studio",
  22. "tags": [
  23. "marketing",
  24. "video",
  25. "remotion",
  26. "branding",
  27. "launch"
  28. ]
  29. }
  30. ]
  31. }
README.md · README · 307 lines
  1. # Marketing Studio
  2. [![verify](https://github.com/ucsandman/marketing-studio/actions/workflows/verify.yml/badge.svg)](https://github.com/ucsandman/marketing-studio/actions/workflows/verify.yml)
  3. An agent-driven local marketing studio. The bundled Claude Code plugin adds `/marketing`
  4. and `/launch`: the agent onboards your brand, films your app, writes the asset suite and
  5. review evidence into that product repo, then prepares guarded distribution to X,
  6. LinkedIn, Facebook, Reddit, Bluesky, and YouTube. Publishing is dry-run by default.
  7. ## The one command
  8. ```
  9. /marketing
  10. ```
  11. One run produces, in order:
  12. | # | Asset | Skill behind it |
  13. |---|-------|-----------------|
  14. | 1 | Logo reveal (Blender + Remotion) | `/logo-reveal` |
  15. | 2 | Product demo with camera zooms and cursor (Playwright capture) | `/product-demo` |
  16. | 3 | 30 to 90 second launch video composing demo, logo, and copy | `/launch-video` |
  17. | 4 | Voiceover and music scored to the launch video (ElevenLabs) | `/audio-track` |
  18. | 5 | Social clips per platform (X, LinkedIn, TikTok) | `/social-clip` |
  19. | 6 | OG image, animated OG loop, README GIF | `/og-assets` |
  20. The order is deliberate: the cheapest composition renders first so brand-token bugs surface before the expensive assets, and the demo is filmed once so its footage can feed downstream work. Audio starts during direction with a scratch voice/music animatic; the final mix is scored against the approved picture. The run keeps a manifest on disk, so a died session resumes where it stopped instead of starting over.
  21. Around those assets, the pipeline adds:
  22. - **A derived content brief.** The agent reads your product repo (README, routes, landing page) and synthesizes the story — hooks, ranked benefit-led features, per-act narration, per-platform copy — into a validated `brief.json` that every builder consumes. You approve the whole story on a storyboard page before anything renders.
  23. - **A copy linter.** Every generated line is gated for em dashes, hype, and AI-slop vocabulary before it can reach a render.
  24. - **A film grade and per-brand motion personality.** Grain, vignette, and bloom tuned per brand, and a `motion` token block so each brand's choreography feels like itself. Grain size is stated at 1080p and scaled by frame height, so an asset carries the same visual grain at 4K. Optional `halation` blooms wherever the frame is *actually* bright rather than glowing a fixed spot, which is the difference between footage that reads photographed and a flat vector comp.
  25. - **An export matrix.** The picture-locked launch video and social clips fan into 16:9, 9:16, 1:1, and 4:5 through responsive layout (not crops), with burned-caption variants for muted autoplay and SRT/VTT sidecars.
  26. - **Mission Control.** A local click-to-approve gallery: watch assets land, review act-boundary contact sheets before the expensive render, approve or request a redo with a note, and the run reacts — no terminal required.
  27. - **Designed sound.** Explicit shot events can request sparse ticks, transitions, or a CTA rise from the shared SFX library. Cuts do not receive automatic whooshes.
  28. - **Word-locked sync.** Voiceover lines carry word-level timestamps; when they do, act lengths derive from the measured voice and reveals land on the words that name them, with `judge-av-sync` verifying every cue against the timings. Wordless manifests render exactly as before.
  29. - **A mastered mix.** Final renders pass a two-pass loudness master to -14 LUFS with a true-peak ceiling, measured in the delivered file rather than trusted from the filter graph, plus SFX asset leveling and per-cue audibility proof.
  30. - **A direction pass.** Finite presets help explore alternatives, but they do not guarantee originality or a fixed number of useful directions. The chosen direction records the product-specific metaphor, references, sound intent, and iteration history.
  31. - **A set judge, not just file judges.** Seven mechanical gates run before any human looks: motion craft, palette, A/V sync, demo dead air, size budgets, audio presence (`check-audio`: every delivered film carries a mastered track with narration), and `judge-drift`, which scores the whole output directory *as a set*. That last one catches the failure no per-file gate can see — assets that are each individually on-brand but collectively fragment into three or four different-looking brands. It emits a worst-first review grid, because attention is reliable over about six tiles, not twenty.
  32. - **Paste-ready post kits and a footage cache.** Every platform gets a folder with the right-aspect video, a lint-gated caption, alt text, and a posting checklist; the kit root also carries `manifest.json`, a machine-readable index that the `launch/` CLI reads to auto-attach videos to X, LinkedIn, Bluesky and YouTube posts, plus `LICENCES.md` and `DISCLOSURE.md` — what is synthetic, which platform toggle to set at upload, and which obligations the kit does *not* yet cover. Unchanged product UIs are never re-filmed thanks to content-hash caching of capture and Blender staging.
  33. Each asset also works standalone: run `/logo-reveal`, `/product-demo`, `/launch-video`, `/audio-track`, `/social-clip`, or `/og-assets` on its own from any repo.
  34. `/ship-it` chains the two halves: `/marketing` renders the suite, then `/launch` posts it with the videos attached, through the same approval gates.
  35. ## Proof and review
  36. Every run keeps its media beside the product that owns it under
  37. `marketing/assets/<brand>/`. Mission Control shows the full film, shot samples, and
  38. review controls from that workspace. A deliverable production run hashes its
  39. direction, shot plan, every routed props source including caption/audio-bearing
  40. variants, canonical staged-public inventory, final render, samples, and review.
  41. Review identity is a local operator attestation, not authenticated identity. Live
  42. publishing revalidates the current bytes and production verdict before upload. The
  43. current four-shot, 782-frame proof has 12 measured samples and zero failures, but
  44. remains incomplete on nine human stage/full-film checks; it is not an agency-quality
  45. claim. See [Production quality](docs/production-quality.md) for the acceptance
  46. contract and [the playbook](docs/PLAYBOOK.md) for the exact commands.
  47. ## How it works
  48. - **One engine, many brands.** Reusable rendering source lives here; every run writes its generated inputs, evidence, renders, and delivery assets into the product repo under `marketing/assets/<brand>/`.
  49. - **Remotion is the backbone.** Every final video renders through Remotion compositions in `studio/` (SocialClip, ProductDemo, LogoReveal, LaunchVideo, AnimatedOG, AgentSession for a scripted Claude Code terminal).
  50. - **Brands are data.** `brands/<id>.json` holds your product's tokens (13 colors, 3 fonts, tagline, voice rules), zod-validated. Templates resolve `getBrand(brandId)` and never hardcode brand values, so a new product is a JSON file and a logo mark component, not a fork.
  51. - **Feeders produce raw material.** Playwright records your running app for demos, headless Blender renders 3D plates, ElevenLabs generates voiceover and music, and ComfyUI can add AI backdrops. Missing required tools produce clear errors; only routes with an explicit documented fallback continue without them.
  52. - **The knowledge lives in the skills.** The `skills/` directory ships the Claude Code skills that operate this repo, including the hard-won gotchas in `docs/PLAYBOOK.md` (camera math, seamless-loop rules, Blender API traps) so the agent does not re-derive them.
  53. The creative acceptance contract, product-owned workspace, baseline evidence, and strict production gate are documented in [Production quality](docs/production-quality.md).
  54. ## Requirements
  55. The engine requires Node 22+ for the studio, Node 24+ for `launch/` (the versions CI
  56. exercises), Python 3.10+, and **ffmpeg on your PATH**. The engine does not require a
  57. particular agent host. Its Python and Node commands can be run by a human or any agent
  58. with local command access.
  59. The packaged slash-command integration is currently specific to
  60. [Claude Code](https://claude.com/claude-code): the plugin manifest, installer destination,
  61. and `${CLAUDE_SKILL_DIR}` paths all use its skill layout. Codex can operate the underlying
  62. engine and can use these skills when an external harness installs them, but this repository
  63. does not yet provide or test native Codex, OpenClaw, or Hermes installers.
  64. Optional: Blender for 3D plates, an ElevenLabs API key for voiceover and music, and ComfyUI for AI backdrops. A workflow must select an explicit fallback before treating any missing optional tool as non-blocking.
  65. **Remotion licence.** Every final video renders through [Remotion](https://www.remotion.dev/), which is free for individuals and for companies of three people or fewer. Larger companies need a Remotion company licence. That is Remotion's term, separate from this repo's MIT licence.
  66. ## Install
  67. ### As a Claude Code plugin
  68. ```
  69. /plugin marketplace add ucsandman/marketing-studio
  70. /plugin install marketing-studio@ucsandman
  71. ```
  72. Plugin skills are namespaced, so the commands are `/marketing-studio:marketing`, `/marketing-studio:logo-reveal`, and so on.
  73. The plugin manifests declare version **2.0.0**. Migrating from 1.x requires a product
  74. repository for every production run: pass `--project <product-repo>` (or invoke a
  75. supported tool from that product worktree). Generated inputs and outputs no longer
  76. default to the installed engine or its legacy `out/` tree.
  77. See the [changelog](CHANGELOG.md) for the release status and migration notes.
  78. The engine ships with the plugin, but its npm dependencies do not. Bootstrap once by asking Claude to *"bootstrap the marketing studio engine"*, or run it yourself against the installed plugin directory:
  79. ```powershell
  80. $pluginDir = "C:\path\to\marketing-studio"
  81. python "$pluginDir\launch.py" --bootstrap
  82. npm --prefix "$pluginDir\feeders\diagram" install
  83. npm --prefix "$pluginDir\launch" install
  84. npm --prefix "$pluginDir\launch" run build
  85. ```
  86. The bootstrap command installs the studio and capture-feeder dependencies and then prints
  87. a toolchain report. The two npm commands install the separate diagram and distribution
  88. packages. Replace `$pluginDir` with the installed plugin directory. Copy `.env.example`
  89. to `.env` there if you have a Blender path or an ElevenLabs key.
  90. ### From source
  91. ```bash
  92. git clone git@github.com:ucsandman/marketing-studio.git
  93. cd marketing-studio
  94. python launch.py --bootstrap # installs studio + capture deps, then checks the toolchain
  95. npm --prefix feeders/diagram ci # optional diagram feeder
  96. npm --prefix launch ci # distribution CLI + dashboard
  97. npm --prefix launch run build
  98. cp .env.example .env # set BLENDER_PATH / ELEVENLABS_API_KEY if you have them
  99. node scripts/install-skills.mjs # installs /marketing and friends into ~/.claude/skills
  100. ```
  101. The included installer puts unnamespaced commands in `~/.claude/skills` (`/marketing`
  102. rather than `/marketing-studio:marketing`). Renderer source stays in the clone; production
  103. inputs and outputs still belong to the selected product repository. Other agent hosts can
  104. run the engine commands directly, but need their own compatible skill installation layer.
  105. Then, from your product's repo:
  106. ```bash
  107. claude
  108. > /marketing
  109. ```
  110. The agent asks one batched round of questions (brand, destination, audio, platforms, checkpoint mode) and runs the whole pipeline. If your brand is new, it derives tokens from your repo's design system (DESIGN.md, Tailwind config, CSS variables) and only asks for what it cannot infer.
  111. ## The skills
  112. | Skill | What it does |
  113. |-------|--------------|
  114. | `/marketing` | The full pipeline: sequencing, gates, run manifest, resume, final QA and delivery gallery |
  115. | `/logo-reveal` | Animated logo reveal video (Blender draw-on choreography composited in Remotion) |
  116. | `/product-demo` | Screen-Studio style demo: films your running app, adds measured camera zooms and cursor |
  117. | `/launch-video` | Hero announcement video composing demo footage, logo reveal, and copy |
  118. | `/audio-track` | Voiceover and music for any video, or standalone audio |
  119. | `/social-clip` | Short feature clips sized per platform |
  120. | `/og-assets` | OG image, animated OG loop, README GIF, social cards |
  121. | `marketing-studio` | Shared background skill: engine workflow, brand onboarding, non-negotiables |
  122. The pipeline's supporting skills ship too, so nothing in the run dangles:
  123. | Skill | What it does |
  124. |-------|--------------|
  125. | `/polish` | Final UI quality pass (alignment, spacing, states, micro-detail) before the demo is filmed |
  126. | `/frontend-verify` | Headless route verification: console errors, failed requests, text assertions |
  127. | `/de-vibe` | Removes the AI-generated fingerprint (security tells, slop copy, generic defaults) before anything ships |
  128. | `/ship` | Verify, docs, secrets scan, commit, push ritual |
  129. | `/ship-it` | `/marketing` then `/launch` in one run: render the suite, post it with the videos attached |
  130. | `/announce` | Announcement drafts per channel (X, LinkedIn, Show HN, email) with approval gates |
  131. | `/launch` | The launch engine end to end: domain, payments, comms, multi-platform posting (dry-run by default, `--live` to post) |
  132. Installing the plugin ships all of them, namespaced under `marketing-studio:`. For a source checkout, `scripts/install-skills.mjs` copies them into `~/.claude/skills` unnamespaced and rewrites the engine path to wherever you cloned this repo; it never overwrites a skill you have symlinked. Two optional plugins deepen the UI-polish phase if you have them (`impeccable` and `frontend-design`); without them the pipeline films your app as-is.
  133. ## Repo layout
  134. ```
  135. .claude-plugin/ plugin + marketplace manifests (this repo installs as a plugin)
  136. brands/ per-product brand tokens (zod-validated JSON)
  137. studio/ Remotion project: all final video compositions
  138. feeders/blender/ headless bpy scenes (3D logo reveals)
  139. feeders/unreal/ headless Unreal Engine 5.8 scenes (story worlds, camera moves; Movie Render Queue)
  140. feeders/capture/ Playwright recorder (product demos)
  141. feeders/audio/ ElevenLabs client (voiceover + music)
  142. feeders/comfy/ ComfyUI client (optional AI backdrops)
  143. skills/ the Claude Code skills that drive all of this (rendering and launch)
  144. launch/ distribution layer: the launch CLI + guarded dashboard (own package)
  145. scripts/ props builders, staging, statics, smoke, copy linter, brief
  146. gatherer, storyboard board, export matrix, captions, thumbs,
  147. post kit, contact sheets, footage cache, SFX library,
  148. Mission Control review server
  149. docs/PLAYBOOK.md the operational reference: engine map, onboarding, process, delivery contract
  150. docs/playbook/ the verified gotchas by topic (remotion, capture, blender, unreal, audio, ...);
  151. read only the topic you are working in
  152. docs/DECISIONS.md durable architecture decisions, newest first
  153. reference/ read-only reference material carried in from retired repos
  154. launch.py single-command health check + Remotion Studio
  155. ```
  156. Engine-local `out/`, `assets/`, `props/`, `examples/`, and
  157. `studio/public/*/` are not product-run destinations. Generated product assets belong
  158. under the product repo's `marketing/assets/<brand>/` workspace.
  159. ## Manual controls
  160. Everything the skills do can be run by hand:
  161. ```bash
  162. python launch.py # health checks + Remotion Studio
  163. node scripts/smoke.mjs # frame-0 still of every composition
  164. node scripts/build-launch-props.mjs <brand> --project <product>
  165. node scripts/lint-copy.mjs <product>/marketing/assets/<brand>/props/<brand>-launch.json
  166. node scripts/render-matrix.mjs <brand> --project <product> --production --stills-only
  167. node scripts/build-captions.mjs <brand> --project <product> --check
  168. node scripts/mission-control.mjs <brand> --project <product>
  169. node scripts/master-audio.mjs <product>/marketing/assets/<brand>/launch.mp4 --project <product>
  170. node scripts/verify-cue.mjs <product>/marketing/assets/<brand>/launch.mp4 2 1.5
  171. node scripts/gates.mjs <brand> --project <product> [--strict] # all seven gates, one row each, drift last; logs in <workspace>/marketing/reports/gates/
  172. node scripts/judge-motion.mjs <brand> --project <product> # one gate on its own, full report
  173. node scripts/build-postkit.mjs <brand> --project <product> --production
  174. node launch/dist/index.js post <product-dir> --all # preview every platform post with the kit attached (dry-run is the default)
  175. node launch/dist/index.js post <product-dir> --all --live # publish for real, through the ledger and media pre-flight
  176. node scripts/publish-bluesky.mjs <brand> --project <product> --dry-run
  177. node scripts/publish-youtube.mjs <brand> --project <product> --dry-run
  178. node scripts/fetch-results.mjs <brand> --project <product>
  179. ```
  180. `docs/PLAYBOOK.md` has the full engine map: every feeder, builder script, and render command, plus the verified gotchas.
  181. ## Adding a brand
  182. 1. `brands/<id>.json` copying the shape of an existing brand (colors, fonts, tagline, voice rules).
  183. 2. Register it in `studio/src/lib/brand.ts` and add a mark component in `studio/src/brands/`.
  184. 3. `cd studio && npm test` validates the schema.
  185. Only `id`, `name`, `tagline`, `url`, `colors` (13), `fonts` (3) and `voice` are required. Other blocks are optional. Most retain legacy defaults; `progressTreatment` intentionally defaults to `none`, and only NoBan opts into the `cs2-wear` FloatBar treatment.
  186. | Block | What it tunes |
  187. |-------|---------------|
  188. | `motion` | Choreography personality — `tempo`, `exuberance`, `stagger`, `overshoot`, `parallax`, `settle`, `textReveal`. Retunes every entrance without moving a rest position. |
  189. | `grade` | The film pass — `grain`, `grainSize` (stated at 1080p, scaled by frame height), `halation` (highlight bloom that samples the frame), `vignette`, `bloom`, `aberration`, `letterbox`. |
  190. | `effects` | `wash` and `glow` behind the mark. Brands whose rules forbid a hero wash set `wash: 0`. |
  191. | `textAccent`, `progressTreatment`, `progressFill` | Colored text plus an optional progress treatment. `none` is the default; only NoBan selects `cs2-wear`. |
  192. | `speechHint` | How the brand name is SPOKEN when that differs from how it is written. The transcriber cannot read a coined word it has never seen, so the audio judge primes it with this. |
  193. `voice` is not decoration — it is parsed. `judge-palette` reads "never <color>" rules out of it and fails renders that violate them, so write the real constraints there.
  194. Keep `grade` restrained. `judge-motion` warns above `grain` 0.4 and `halation` 0.35: past those, grain reads as compression noise and halation reads as a CSS glow rather than light scattering off film.
  195. The `/marketing` skill does all of this for you from your product repo's design system; the steps above are the manual path. Details in `docs/PLAYBOOK.md`.
  196. ## Verification
  197. ```bash
  198. node scripts/verify.mjs # root tests, studio tests, studio lint, smoke: one row each, logs in out/verify/
  199. python launch.py --check # toolchain health
  200. python -m unittest discover -s feeders -p 'test_workspace.py' -v
  201. ```
  202. The four suites can also run on their own (`node scripts/smoke.mjs`, `cd studio && npm test`,
  203. `cd studio && npm run lint`, and the `node --test` line in `.github/workflows/verify.yml`).
  204. `verify.mjs` exists so an agent reads four lines instead of 700.
  205. Every asset prop is nullable with a placeholder, so the smoke test passes on a clean clone with no captures, no Blender, and no API keys.
  206. ## Speed and token budget
  207. Measured 2026-09-06 on a 24-core RTX 3070 Ti workstation (Remotion 4.0.486), the render
  208. harness is not where time goes: `remotion bundle` is 1.5 s warm and Chrome renders a
  209. 1080p frame in about 0.4 s. What moved the numbers:
  210. - **GPU rendering is the default.** `studio/remotion.config.ts` sets
  211. `chrome-for-testing` + `angle`: LaunchVideo and LogoReveal render 4 to 5x faster
  212. (60 frames: 28 to 33 s down to 6 to 8 s), stills unchanged, output visually identical.
  213. `REMOTION_GPU=0` restores the headless shell; CI never downloads Chrome for Testing.
  214. - **Renders are quiet.** Every script shells to Remotion through
  215. `scripts/lib/remotion.mjs`: the checked-in CLI via Node (the `npx` shim fails with
  216. `EINVAL` on Windows), `--log=error`, one summary line per render instead of one
  217. progress line per frame, the last 40 log lines when a render dies.
  218. `REMOTION_VERBOSE=1` shows everything.
  219. - **Gates and suites print rows, not reports.** `scripts/gates.mjs` and
  220. `scripts/verify.mjs` write the full output to disk and print one line per gate or
  221. suite with the counts they processed.
  222. - **Agents read the topic, not the book.** `docs/PLAYBOOK.md` is the short reference;
  223. the gotchas live in `docs/playbook/<topic>.md` and each skill names only the files
  224. its recipe needs.
  225. The design and the measurements are in
  226. [`docs/superpowers/specs/2026-09-06-speed-and-token-budget-design.md`](docs/superpowers/specs/2026-09-06-speed-and-token-budget-design.md).
  227. ## launch/ (distribution layer)
  228. `launch/` is the launch engine as a sub-package (`@marketing-studio/launch`), folded in from the standalone launch-engine repo on 2026-09-02. It takes a shipped product the rest of the way: `launch init` scans the product repo into `<product>/.launch/`, `launch research` and `launch copy` write per-platform briefs and drafts validated against each platform's hard limits, and `launch post` publishes to X, LinkedIn, Facebook, Reddit, Google Search Console, Bluesky and YouTube, with assisted flows for Hacker News and Product Hunt.
  229. Safety is the default: `launch post` previews unless you pass `--live`, every post consults an idempotency ledger before any network call, videos are refused before upload when they exceed a platform's duration or size cap, and the local dashboard (`launch ui`) binds to 127.0.0.1 with a per-run token and a typed-domain confirmation for live publishing. Social keys come from `launch/.env` (template in `launch/.env.example`); infrastructure credentials (domain, Vercel, Stripe, Resend, Twilio, DNS) never enter this package and are reached only through the offlocal MCP server from the `/launch` skill.
  230. It keeps its own toolchain (`cd launch && npm ci && npm run build && npm test`, Node 24), gated by the `launch` job in CI. Full docs: [launch/README.md](launch/README.md); provider setup guides in [launch/docs/](launch/docs/).
  231. ## License
  232. MIT
  233. ## Support
  234. If my tools save you time, you can support my work here:
  235. [![Sponsor on GitHub](https://img.shields.io/badge/GitHub%20Sponsors-%E2%9D%A4-db61a2?logo=githubsponsors&logoColor=white)](https://github.com/sponsors/ucsandman)
  236. [![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-%E2%98%95-ffdd00?logo=buymeacoffee&logoColor=black)](https://buymeacoffee.com/wes_sander)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.