Marketing Studio

An agent-driven local marketing studio. The bundled Claude Code plugin adds /marketing and /launch: the agent onboards your brand, films your app, writes the asset suite and review evidence into that product repo, then prepares guarded distribution to X, LinkedIn, Facebook, Reddit, Bluesky, and YouTube. Publishing is dry-run by default.

The one command

/marketing

One run produces, in order:

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.

Around those assets, the pipeline adds:

• 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.
• A copy linter. Every generated line is gated for em dashes, hype, and AI-slop vocabulary before it can reach a render.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.

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.

/ship-it chains the two halves: /marketing renders the suite, then /launch posts it with the videos attached, through the same approval gates.

Proof and review

Every run keeps its media beside the product that owns it under marketing/assets/<brand>/. Mission Control shows the full film, shot samples, and review controls from that workspace. A deliverable production run hashes its direction, shot plan, every routed props source including caption/audio-bearing variants, canonical staged-public inventory, final render, samples, and review. Review identity is a local operator attestation, not authenticated identity. Live publishing revalidates the current bytes and production verdict before upload. The current four-shot, 782-frame proof has 12 measured samples and zero failures, but remains incomplete on nine human stage/full-film checks; it is not an agency-quality claim. See Production quality for the acceptance contract and the playbook for the exact commands.

How it works

• 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>/.
• 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).
• 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.
• 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.
• 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.

The creative acceptance contract, product-owned workspace, baseline evidence, and strict production gate are documented in Production quality.

Requirements

The engine requires Node 22+ for the studio, Node 24+ for launch/ (the versions CI exercises), Python 3.10+, and ffmpeg on your PATH. The engine does not require a particular agent host. Its Python and Node commands can be run by a human or any agent with local command access.

The packaged slash-command integration is currently specific to Claude Code: the plugin manifest, installer destination, and ${CLAUDE_SKILL_DIR} paths all use its skill layout. Codex can operate the underlying engine and can use these skills when an external harness installs them, but this repository does not yet provide or test native Codex, OpenClaw, or Hermes installers.

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.

Remotion licence. Every final video renders through Remotion, 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.

Install

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 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.

The skills

The pipeline's supporting skills ship too, so nothing in the run dangles:

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.

Repo layout

.claude-plugin/    plugin + marketplace manifests (this repo installs as a plugin)
brands/            per-product brand tokens (zod-validated JSON)
studio/            Remotion project: all final video compositions
feeders/blender/   headless bpy scenes (3D logo reveals)
feeders/unreal/    headless Unreal Engine 5.8 scenes (story worlds, camera moves; Movie Render Queue)
feeders/capture/   Playwright recorder (product demos)
feeders/audio/     ElevenLabs client (voiceover + music)
feeders/comfy/     ComfyUI client (optional AI backdrops)
skills/            the Claude Code skills that drive all of this (rendering and launch)
launch/            distribution layer: the launch CLI + guarded dashboard (own package)
scripts/           props builders, staging, statics, smoke, copy linter, brief
                   gatherer, storyboard board, export matrix, captions, thumbs,
                   post kit, contact sheets, footage cache, SFX library,
                   Mission Control review server
docs/PLAYBOOK.md   the operational reference: engine map, onboarding, process, delivery contract
docs/playbook/     the verified gotchas by topic (remotion, capture, blender, unreal, audio, ...);
                   read only the topic you are working in
docs/DECISIONS.md  durable architecture decisions, newest first
reference/         read-only reference material carried in from retired repos
launch.py          single-command health check + Remotion Studio

Engine-local out/, assets/, props/, examples/, and studio/public/*/ are not product-run destinations. Generated product assets belong under the product repo's marketing/assets/<brand>/ workspace.

Manual controls

Everything the skills do can be run by hand:

python launch.py                    # health checks + Remotion Studio
node scripts/smoke.mjs              # frame-0 still of every composition
node scripts/build-launch-props.mjs <brand> --project <product>
node scripts/lint-copy.mjs <product>/marketing/assets/<brand>/props/<brand>-launch.json
node scripts/render-matrix.mjs <brand> --project <product> --production --stills-only
node scripts/build-captions.mjs <brand> --project <product> --check
node scripts/mission-control.mjs <brand> --project <product>
node scripts/master-audio.mjs <product>/marketing/assets/<brand>/launch.mp4 --project <product>
node scripts/verify-cue.mjs <product>/marketing/assets/<brand>/launch.mp4 2 1.5
node scripts/gates.mjs <brand> --project <product> [--strict]   # all seven gates, one row each, drift last; logs in <workspace>/marketing/reports/gates/
node scripts/judge-motion.mjs <brand> --project <product> # one gate on its own, full report
node scripts/build-postkit.mjs <brand> --project <product> --production
node launch/dist/index.js post <product-dir> --all      # preview every platform post with the kit attached (dry-run is the default)
node launch/dist/index.js post <product-dir> --all --live   # publish for real, through the ledger and media pre-flight
node scripts/publish-bluesky.mjs <brand> --project <product> --dry-run
node scripts/publish-youtube.mjs <brand> --project <product> --dry-run
node scripts/fetch-results.mjs <brand> --project <product>

docs/PLAYBOOK.md has the full engine map: every feeder, builder script, and render command, plus the verified gotchas.

Adding a brand

1. brands/<id>.json copying the shape of an existing brand (colors, fonts, tagline, voice rules).
2. Register it in studio/src/lib/brand.ts and add a mark component in studio/src/brands/.
3. cd studio && npm test validates the schema.

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.

voice is not decoration — it is parsed. judge-palette reads "never " rules out of it and fails renders that violate them, so write the real constraints there.

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.

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.

Verification

node scripts/verify.mjs    # root tests, studio tests, studio lint, smoke: one row each, logs in out/verify/
python launch.py --check   # toolchain health
python -m unittest discover -s feeders -p 'test_workspace.py' -v

The four suites can also run on their own (node scripts/smoke.mjs, cd studio && npm test, cd studio && npm run lint, and the node --test line in .github/workflows/verify.yml). verify.mjs exists so an agent reads four lines instead of 700.

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.

Speed and token budget

Measured 2026-09-06 on a 24-core RTX 3070 Ti workstation (Remotion 4.0.486), the render harness is not where time goes: remotion bundle is 1.5 s warm and Chrome renders a 1080p frame in about 0.4 s. What moved the numbers:

• GPU rendering is the default. studio/remotion.config.ts sets chrome-for-testing + angle: LaunchVideo and LogoReveal render 4 to 5x faster (60 frames: 28 to 33 s down to 6 to 8 s), stills unchanged, output visually identical. REMOTION_GPU=0 restores the headless shell; CI never downloads Chrome for Testing.
• Renders are quiet. Every script shells to Remotion through scripts/lib/remotion.mjs: the checked-in CLI via Node (the npx shim fails with EINVAL on Windows), --log=error, one summary line per render instead of one progress line per frame, the last 40 log lines when a render dies. REMOTION_VERBOSE=1 shows everything.
• Gates and suites print rows, not reports. scripts/gates.mjs and scripts/verify.mjs write the full output to disk and print one line per gate or suite with the counts they processed.
• Agents read the topic, not the book. docs/PLAYBOOK.md is the short reference; the gotchas live in docs/playbook/<topic>.md and each skill names only the files its recipe needs.

The design and the measurements are in docs/superpowers/specs/2026-09-06-speed-and-token-budget-design.md.

launch/ (distribution layer)

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.

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.

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; provider setup guides in launch/docs/.

License

MIT

Support

If my tools save you time, you can support my work here: