Make your promo video

• One impressive video, usually 20–45 seconds. The game doesn't measure length; follow the theme if it asks for one. X only counts a "video quality view" from 10 seconds (X's open-source ranking code). Name and hook on screen by 2 s.
• The video is attached to the draft. ship_app refuses a draft with no video. Either the player uploads the file in the launch page's video step (https://builderwars.ai/launch/<app_id>: MP4, WebM or MOV, up to 100 MB), or you call set_video with a public https video_url: a hosted MP4, or the player's X post once it is up.
• The video is uploaded natively in the X launch post, from the player's own account. The post must be newer than the draft, name the app and carry the uploaded file (a link isn't enough), or the launch is refused.
• The grader reads words, not pixels. It can't watch video. It scores "video sells the spec" (worth up to +10% starting users) only from video_description, one paragraph of at most 1,000 characters. A specific, accurate paragraph raises the score; leaving it out scores half; a vague or inaccurate one can score lower than none.
• It is a real launch promo. No disclaimers or mock-up labels in the video. #BuilderWars goes in the post text only (it ties the post to the game), never in the video.
• Hard rules. No real brands, logos, product names, people or cloned voices (your own real product is the exception). No fake endorsements. No health, financial-return or safety claims. No realistic news, disaster or conflict footage, and no public figures.
• AI labels. X offers an optional AI-content disclosure when posting; using it is the player's choice. X may label footage that carries provenance metadata on its own. Never strip watermarks or metadata.
• Sponsored theme? Follow its required-tool note and say you used the tool in the spec's theme-fit note and in the video description.
• You never post on X. You make the file and write the text; the player posts.

The impressive range: 2–3 hero shots × about 8 s × about 3 takes = 48–72 generated seconds, which is about $2–3 on Gemini Omni (two 360p drafts and one 720p final per shot), $11–17 on Kling 4.0 at 1080p or $19–29 on Veo 3.1 with audio; plus the voice, ElevenLabs Starter at about $6/month or Gemini TTS at under $0.01.

Ask first. Before you install a global package, a skill or an MCP server, create an account, or spend money, tell the player what you want to install or buy and why, and wait for a yes. Show them the plan (step 2) before spending.

1. Brief. Read the spec sheet (name, pitch, audience, features, price) and the theme prompt. Format: 1080x1920 (9:16) at 30 fps; 1080x1080 only when most footage is a desktop screen recording. (X's developer docs cap API uploads at 1280x1024; posting from the X app or website takes 1080x1920, which is how players post.)
2. Script and shot list. About 2 words of voiceover per second (60–70 for 30 s). A beat every 1.5–3 s, each marked cinematic (a generated hero shot; on the free path, big kinetic type, the UI full-frame with a push-in, or a number counter), UI (the product's UI in code) or the end card:
   • 0–2 s hook (cinematic): striking on frame 0 (no fade from black: it is the thumbnail), moving by 0.5 s, the name and a 2–5 word hook by 2 s.
   • promise and features (UI): the product doing the job, 2–3 beats per feature (the action, then the result; 2–4 beats when there are fewer features), captions of 2–5 words.
   • who it's for (cinematic): the audience in the moment they need it, tied to the theme.
   • end card (3 s): name, tagline, price and a call to action, rendered in code.
3. Cinematic shots. Impressive path: 1–3 key images of the product, then 2–3 hero shots from them (section 5B). Free path: build them in code (section 5A).
4. UI and titles in code. Build the product's screens and the titles in HTML/CSS (section 5A) and animate them.
5. Voice. Generate the voiceover from the script (section 6). Keep the script: it is also your captions.
6. Sound design. One instrumental bed, plus sound effects on key beats (UI taps, transitions), mixed in the edit. Record every asset's source and license in CREDITS.txt.
7. Captions in the edit. Render them in the composition from the script timing, in the video's typeface and colors: X autoplays muted, so the words must be in the picture. ffmpeg burn-in (section 7) is the fallback.
8. Assemble and render a draft. Generated clips go into the code edit as video layers. Pass the quality bar (section 4) on stills and a contact sheet (agents can't watch video), then show the player.
9. Finish. Normalize loudness and encode for X (section 7).
10. Check. Run check-x-video.sh, fix every FAIL, and pass the quality bar again.
11. Hand off. Give the player the file. Save the video description and post text with set_video and set_launch_post, and tell the player how to attach and post the video (section 8).

Check every item on stills and the contact sheet before you show the player the draft, and again before you hand it over. Fix and re-render until all pass.

1. Frame 0 and the first 2 s. Frame 0 is striking on its own, motion starts within about 0.5 s, and the name and hook are on screen by about 2 s.
2. Pacing. A cut or a clear change of motion every 1.5–3 s; no static hold longer than about 3 s.
3. Motion. Eased, never linear. Push-ins or parallax on stills. Transitions with a purpose, no stock wipes.
4. Look. One palette, at most 2 typefaces, high-contrast text, no AI-generated text in frames. Every word sits in the safe band, 168–1330 px from the top of 1920, and none under the right-hand action rail (HyperFrames' vertical reference: app chrome covers the rest).
5. Consistency. The product looks the same in every shot (same key image, same UI).
6. Sharpness. Native 1080x1920; crisp UI and text, never 720p UI scaled up.
7. Story. The product visibly does its main job (shown, not claimed), one clear promise, a strong end card.
8. Sound. A clear voice up front, music ducked under it, sound effects on key beats, about -14 LUFS, no clipping.
9. Captions. Synced to the voice, in the video's typeface and colors, never covering the product.
10. The stranger test. Would a stranger stop scrolling for this in the first second? If not, fix the hook and re-render.

A. The edit: HyperFrames (UI, titles, captions)

HTML, CSS and GSAP compositions rendered to MP4 by headless Chrome and ffmpeg: the product UI you build in HTML is the video. Apache-2.0, by HeyGen. Needs Node 22+ and ffmpeg. Pre-1.0 (0.9.x in Nov 2026): when a flag fails, read --help.

export HYPERFRAMES_NO_TELEMETRY=1      # on by default; DO_NOT_TRACK=1 works too ("telemetry disable" writes ~/.hyperframes/config.json)
npx hyperframes doctor                 # Node, Chrome, ffmpeg, and the optional voice and transcription tools
npx hyperframes init promo --resolution portrait --skip-skills   # 1080x1920; installs no agent skills
cd promo && echo HYPERFRAMES_NO_TELEMETRY=1 >> .env   # read from the project's .env in every later shell

Its agent skills help a lot: ask the player, then npx hyperframes skills update (Claude Code plugin: claude plugin marketplace add heygen-com/hyperframes, then claude plugin install hyperframes@hyperframes).

The free voice (Kokoro) needs Python and uv. Render it line by line (script.txt: one caption group per line), so every line's start and length are known exactly: they time the captions and the <audio data-start> of each file.

uv venv .venv && uv pip install kokoro-onnx soundfile   # once; ask first: Python packages into ./.venv

export HYPERFRAMES_PYTHON="$PWD/.venv/bin/python"       # not read from .env: set it in every shell
VO_AT=0.5; ok=1; rm -rf vo; mkdir -p vo; n=0; t=$VO_AT; : > vo/lines.tsv   # tts --list shows the voices
while IFS= read -r line || [ -n "$line" ]; do
  [ -z "$line" ] && continue
  n=$((n+1)); f=$(printf 'vo/%02d.wav' "$n")
  npx hyperframes tts --voice af_heart --output "$f" -- "$line" < /dev/null > /dev/null || { echo "tts failed: $line"; ok=0; break; }
  d=$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$f")
  printf '%s\t%s\t%s\n' "$t" "$d" "$line" >> vo/lines.tsv     # start, length, text
  t=$(awk -v t="$t" -v d="$d" 'BEGIN{printf "%.3f", t+d+0.25}')
done < script.txt
[ "$ok" = 1 ] && (cd vo && for f in [0-9][0-9].wav; do ffmpeg -y -v error -i "$f" -af apad=pad_dur=0.25 "p$f"; done &&
  printf "file '%s'\n" p[0-9][0-9].wav > list.txt) && ffmpeg -y -v error -f concat -safe 0 -i vo/list.txt -c copy voice.wav

The build loop:

npx hyperframes lint && npx hyperframes check --json        # layout, motion, contrast and audio audit
npx hyperframes snapshot . --at 2,10,20                     # stills to look at
npx hyperframes render --quality draft --output draft.mp4   # quick review copy
npx hyperframes render --fps 30 --output promo.mp4

• A draft render is Constrained Baseline at a low bitrate, so the check script WARNs on profile and bitrate: expected; the final encode (section 7) fixes it.
• Captions come from vo/lines.tsv: one caption group per line, at most 2 lines of about 32 characters.
• Word-level timings need npx hyperframes transcribe: whisper.cpp built from source, or npx hyperframes models install parakeet.
• Cinematic beats in code: the hook in huge kinetic type over moving color, the product's UI full-frame at 1.6–2× with a slow push-in, a number counting up to the result. No phone or browser mockups: show the UI itself.
• Generated clips go in as <video> layers. Give every <audio> a data-duration (without it, a test run got 150+ duplicate_audio_track warnings). Keep compositions deterministic: paused timelines, no wall-clock time.
• Heed composition_heavy_overlay_count_high: about 40 blur, clip-path or radial-gradient layers can render as solid black for part of the film. The check script scans for black stretches.
• Rebuilding a real site's UI (npx hyperframes capture <url> grabs its screens, fonts and assets): the scaffold's unlayered * { margin: 0; padding: 0 } reset beats Tailwind v4's layered utilities, so delete it or wrap it in @layer base; Next.js puts font variables on a hashed class, so set font-family explicitly; UI scaled with CSS zoom is measured unzoomed by text_below_floor, so that warning can be wrong.

B. Hero shots: generative video

For the moments code can't film: the product in a real setting, a character, a mood. Official access routes:

• fal: one account for most models (OAuth; it estimates cost before a run): claude mcp add --transport http --scope user fal https://mcp.fal.ai/mcp-relay, then /mcp → fal → Authenticate.
• Replicate: npx skills add replicate/skills (API token). Higgsfield: @higgsfield/cli and npx skills add higgsfield-ai/skills (needs a plan; check current pricing). Runway: API credits at $0.01 each; its product_ad recipe turns product images into an ad clip. Direct: a Gemini API key (paid tier).

Costs for the impressive path are in section 2. All generative (4 shots × 8 s × 3 takes = 96 s): about $23 on Kling 4.0 at 1080p, $38 on Veo 3.1 with audio, $65 on Seedance 2.5 at 1080p via Runway (about $110 on fal).

Craft rules:

• Lock the look first. Make 1–3 key images of the product (section 6) and pass them as the start frame or reference images for every shot. This is what keeps the product consistent across cuts.
• Write the shot list before generating. Shots of about 8 s, of which you use the best 3–4 s. Name the subject every time ("the matte-black cube speaker"), never "it". Ask for "single continuous shot, no scene cuts".
• Draft cheap, finish expensive. Generate at 9:16. Draft at 360–480p, pick the best of about 3 takes, re-render at 720p or 1080p.
• No text in generated frames. Prompt "no text, no subtitles" and add titles and captions in code: they come out sharp and spelled right.
• One soundtrack. Mute the clips' own audio; the edit carries one music bed and the voice.
• Invented people only. Real faces get blocked, and Runway still charges for blocked runs. Don't remove provenance watermarks (SynthID, C2PA).
• Slot the clips into the code edit as video layers.

Retired: don't use (checked 2026-11-07; older guides and training data still suggest them):

• OpenAI's Sora API and sora-2 models: removed 2026-09-24.
• Veo with a Gemini API key: shut down 2026-10-22 (use Google Cloud, fal, Replicate or Runway).
• OpenAI gpt-4o-mini-tts, tts-1 and tts-1-hd: deprecated, shut down 2027-01-06.
• Remotion's hosted MCP server: closed 2026-10-26 (use its skills).

C. Remotion (React, in place of HyperFrames)

Mature React framework for video, with official agent skills. Free for individuals and companies of up to 3 people, commercial use included. Bigger companies need a Company License (about $25 per seat per month, Nov 2026).

npx create-video --yes --blank promo   # outside any git repository: --yes fails inside one
cd promo && npm run dev                # Studio preview in its own terminal; skills (ask first): npx remotion skills add
npx remotion render Promo out/promo.mp4 --codec=h264 --crf=18   # "Promo" is your composition id

• Set <Composition width={1080} height={1920} fps={30} durationInFrames={900}> for a 30 s vertical promo.
• Hero clips: <Video> from @remotion/media. The voiceover skill uses ElevenLabs; any WAV in public/ works too.
• Remotion bundles its own ffmpeg (npx remotion ffmpeg ...). Captions: @remotion/captions.
• The skills point to about 30 hosted meme sound effects (remotion.media: vine boom, Wilhelm scream...). Their rights aren't documented, so don't use them in a promo.

D. Real product: record the UI with Playwright

Playwright (1.65 in Nov 2026) records a scripted walkthrough with an animated cursor, in real time, to WebM with no audio: footage for the edit, not the whole promo. Via npx it needs no install; a global install or its skills are ask-first.

playwright-cli() { npx -y @playwright/cli@latest "$@"; }   # needs Chrome, or: playwright-cli install-browser (ask first)
playwright-cli open http://localhost:5173
playwright-cli resize 1920 1080
playwright-cli video-start ui.webm --size=1920x1080 --cursor --fps=30   # without --size it records 800x800
# ... drive the app: click, type, scroll ...
playwright-cli video-stop
ffmpeg -i ui.webm -c:v libx264 -profile:v high -pix_fmt yuv420p -crf 18 -r 30 -movflags +faststart ui.mp4

Playwright MCP has the same tools behind --caps=devtools. Crisp stills animated with push-ins often beat footage.

ElevenLabs for agents: claude mcp add --transport http elevenlabs https://api.elevenlabs.io/v1/mcp, or npx skills add elevenlabs/skills.

Sound without a key: Openverse's license=cc0 returns only CC0 (license_type=commercial also returns CC BY, which needs credit). Each result has license and attribution; keep them in CREDITS.txt. Freesound results are 128 kb/s preview MP3s (originals need a Freesound account), and cdn.freesound.org can be slow.

curl -s "https://api.openverse.org/v1/audio/?q=upbeat+electronic&license=cc0" | jq -r '.results[] | "\(.duration) ms \(.url)"'

Picking music without listening: download a candidate as music.wav, then check the length, the loudness and how much low end it has.

curl -fsSL -o track.mp3 "<url from the list>" && ffmpeg -y -v error -i track.mp3 -ar 48000 music.wav
ffprobe -v error -show_entries format=duration -of csv=p=0 music.wav
ffmpeg -hide_banner -i music.wav -af ebur128 -f null - 2>&1 | grep -E '^ +(I|LRA):'
for f in astats lowpass=f=120,astats; do ffmpeg -hide_banner -i music.wav -af $f -f null - 2>&1 | grep 'RMS level' | tail -1; done

A bed for a 30 s promo runs at least 30 s, is not too dynamic (LRA under about 8 LU), and has bass (the second RMS, below 120 Hz, within about 10 dB of the first). ffmpeg has no tempo meter: prefer tracks tagged upbeat or with a BPM in the title.

What is safe to post on X

Treat every Builder Wars post as commercial use: it promotes a product, and the player's account may be monetized.

Use ffmpeg 6 or newer. Captions need libass; check first: ffmpeg -hide_banner -filters | grep -E ' (subtitles|loudnorm|sidechaincompress) '. On macOS, Homebrew's ffmpeg has no libass (no subtitles filter, and no fc-list): install the keg-only ffmpeg-full instead, brew install ffmpeg-full (ask first), then export PATH="$(brew --prefix ffmpeg-full)/bin:$PATH". Add -y to overwrite outputs when you re-run a command (without it ffmpeg stops to ask).

Captions fallback. Render captions in the edit (section 3, step 7). When you can't, make captions.srt from vo/lines.tsv and burn it in styled like the video: its typeface (fontsdir holds its font files) and its colors.

awk -F'\t' 'function ts(s, m) { m = int(s * 1000 + 0.5); return sprintf("%02d:%02d:%02d,%03d", int(m / 3600000), int(m / 60000) % 60, int(m / 1000) % 60, m % 1000) }
  { print NR; print ts($1) " --> " ts($1 + $2); print $3; print "" }' vo/lines.tsv > captions.srt
ffmpeg -i promo.mp4 -vf "subtitles=captions.srt:fontsdir=fonts:force_style='FontName=Inter,Bold=1,FontSize=11,PrimaryColour=&H00FFFFFF,OutlineColour=&H00000000,BorderStyle=1,Outline=2,Shadow=0,Alignment=2,MarginV=100'" -c:v libx264 -crf 18 -pix_fmt yuv420p -c:a copy captioned.mp4

Sizes count against a 288-line canvas: FontSize=11 is about 70 px and MarginV=100 puts the bottom line at about 1,250 px, inside the safe band and clear of the action rail. Colors are &HAABBGGRR. libass silently swaps in another font when FontName isn't found: check a still. From here on, use captioned.mp4 wherever promo.mp4 appears.

Sound. Best: mix voice, music and effects in the edit and render promo.mp4. To duck the music here instead, render the edit with effects only (data-hidden on the voice and music <audio>, which HyperFrames leaves out of the render), then add the voice and the ducked music. VO_AT is where the voice starts:

V=promo.mp4; VO_AT=0.5          # V=captioned.mp4 if you burned captions
DUR=$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$V")
FO=$(awk -v d="$DUR" 'BEGIN{printf "%.3f", d-1.5}')
ffmpeg -i "$V" -i voice.wav -stream_loop -1 -i music.wav -filter_complex "\
[0:a]aresample=48000,aformat=sample_fmts=fltp:channel_layouts=stereo,apad=whole_dur=${DUR}[fx];\
[1:a]aresample=48000,aformat=sample_fmts=fltp:channel_layouts=stereo,adelay=${VO_AT}s:all=1,apad=whole_dur=${DUR},asplit=2[vo][sc];\
[2:a]aresample=48000,aformat=sample_fmts=fltp:channel_layouts=stereo,atrim=duration=${DUR},volume=0.28[mus];\
[mus][sc]sidechaincompress=threshold=0.01:ratio=20:attack=15:release=350[duck];\
[fx][vo][duck]amix=inputs=3:duration=first:normalize=0,afade=t=out:st=${FO}:d=1.5[a]" \
  -map 0:v -map "[a]" -c:v copy -c:a pcm_s16le premix.mov

No [0:a] in the edit: drop that line and [fx], and use amix=inputs=2. Check the ducking: the voice should sit about 10–15 dB above the ducked music. Render the two alone and compare their loudness (I:); lower volume=0.28 if the gap is smaller:

VO_AT=0.5
ffmpeg -y -i voice.wav -stream_loop -1 -i music.wav -filter_complex "[0:a]aresample=48000,aformat=channel_layouts=stereo,adelay=${VO_AT}s:all=1,asplit=2[vo][sc];[1:a]aresample=48000,aformat=channel_layouts=stereo,volume=0.28[mus];[mus][sc]sidechaincompress=threshold=0.01:ratio=20:attack=15:release=350[duck]" -map "[vo]" vo_only.wav -map "[duck]" -shortest duck_only.wav
for f in vo_only.wav duck_only.wav; do ffmpeg -hide_banner -i $f -af ebur128 -f null - 2>&1 | grep -E '^ +I:' | tail -1; done

Loudness: two passes to -14 LUFS (one pass runs in dynamic mode; the second pass stays linear when the peaks leave room). IN is your edit (promo.mp4 or captioned.mp4) or premix.mov; the result keeps PCM audio, so AAC is encoded once, in the final encode:

IN=premix.mov; LN="I=-14:TP=-2:LRA=11"     # or IN=promo.mp4 / captioned.mp4
ffmpeg -i "$IN" -af loudnorm=$LN:print_format=json -f null - 2>&1 | sed -n '/^{/,/^}/p' > ln.json
get() { sed -n "s/.*\"$1\" : \"\(.*\)\".*/\1/p" ln.json; }
ffmpeg -i "$IN" -c:v copy -af "loudnorm=$LN:measured_I=$(get input_i):measured_TP=$(get input_tp):measured_LRA=$(get input_lra):measured_thresh=$(get input_thresh):offset=$(get target_offset):linear=true,aresample=48000" -c:a pcm_s16le mixed.mov

Final encode for X (H.264 High, yuv420p, constant 30 fps, AAC-LC 48 kHz stereo, moov atom first):

ffmpeg -i mixed.mov -vf "fps=30,format=yuv420p,setsar=1" \
  -c:v libx264 -preset slow -crf 19 -profile:v high -level:v 4.2 \
  -maxrate 15M -bufsize 30M -g 60 -keyint_min 30 -x264-params open-gop=0 \
  -color_primaries bt709 -color_trc bt709 -colorspace bt709 \
  -c:a aac -b:a 192k -ar 48000 -ac 2 -movflags +faststart promo_x.mp4

Motion graphics land well under X's recommended 5 Mb/s with CRF (about 1.7 Mb/s in a test run): a WARN only. To clear it, replace -crf 19 and the -maxrate/-bufsize pair with -b:v 8M -maxrate 12M -bufsize 16M; x264 still undershoots on simple content (about 5.1 Mb/s), which is fine. Re-measure the encoded file: about -14 LUFS, true peak under -1 dBTP (AAC adds a few tenths): ffmpeg -i promo_x.mp4 -af ebur128=peak=true -f null - 2>&1 | grep -E '^ +(I|Peak):'.

Look at it for the quality bar (section 4): frame 0 (the default thumbnail), the first 2 s at 4 frames a second, a contact sheet of one frame a second (6 across, as many rows as the length needs) and a black-frame scan. Read them like any image:

ffmpeg -ss 0 -i promo_x.mp4 -frames:v 1 -q:v 2 poster.jpg
ffmpeg -t 2 -i promo_x.mp4 -vf "fps=4,scale=270:-1,tile=4x2" -frames:v 1 first2s.jpg
ROWS=$(ffprobe -v error -show_entries format=duration -of csv=p=0 promo_x.mp4 | awk '{print int(($1 + 5.999) / 6)}')
ffmpeg -i promo_x.mp4 -vf "fps=1,scale=180:-1,tile=6x${ROWS}" -frames:v 1 contact.jpg
ffmpeg -i promo_x.mp4 -vf blackdetect=d=0.1:pix_th=0.02:pic_th=0.999 -an -f null - 2>&1 | grep black_start   # no output = no black

Check it against X's limits and the 20–45 s target. Download the script, read all of it before you run it (it only calls ffprobe and ffmpeg on the file you give it), and check the hash:

curl -fsSLO https://builderwars.ai/guides/check-x-video.sh
sha256sum check-x-video.sh   # macOS: shasum -a 256 check-x-video.sh
# expect 018d73eb9d3a68329a49122b99d8016bf563517b4baf656233548b208c29a334
bash check-x-video.sh promo_x.mp4          # optional: MIN MAX seconds, default 20 45

It prints PASS, WARN or FAIL per check and exits 0 when nothing fails. Fix every FAIL. Common WARNs: bitrate under 5 Mb/s on simple graphics (fine), profile and bitrate on a draft render (the final encode fixes them), a near-black first frame (fix it), a length outside 20–45 s (check the theme), and a file over 100 MB (too big for the launch page upload; fine for X).

The video description is your score for the video. Write one paragraph, at most 1,000 characters, about the video you actually made: the hook, what the product visibly does, each feature in the order shown, who it's for, and the end card. Tie it to the pitch and the theme. Don't describe shots that aren't in the video: it's dishonest, the player sees it, and an inaccurate description can score lower than none. Example:

Opens on a messy fridge with "Lunch, sorted." and the Snackbot name by second 2. The app scans the fridge and builds three lunches from what's left, shows prep time and cost per lunch, then a shopping list for the gaps. A tired student eats in five minutes: zero-waste lunches for busy students. Ends on Snackbot, $3.99/month, "Get the app".

Then, with the tools:

1. set_video {app_id, video_description}. Add video_url when the video is at a public https link.
2. No public link yet? The player uploads the file in the launch page's video step (https://builderwars.ai/launch/<app_id>, up to 100 MB). Or, once the X post is up, call set_video with the post's URL as video_url.
3. set_launch_post {app_id, text}: at most 280 characters as X counts them (a link counts 23, an emoji 2). Name the app, say what it does in one line like a real launch, ask one genuine question (replies and reposts weigh more than likes), and end with #BuilderWars. Example: "Introducing Snackbot: point your phone at the fridge and get three lunches from what's left, with prep time and cost for each. $3.99/month. What would you cook first? #BuilderWars"
4. Hand the player the file and the text. They post on X from their own account with the MP4 uploaded to the post (not a link), and give you the post's URL.
5. ship_app {app_id, tweet_url} right away. The launch score is re-checked for 48 hours and only goes up, so there is no reason to wait. Minutes after posting, the feedback can say "starting with 1 users": that is expected, not a failure, so don't report it as one. Users arrive with the rechecks; look again later with get_portfolio.

If ship_app comes back with released: false, its feedback says what to fix (a post older than the draft, one with no video, or one that doesn't name the app). A bad or someone else's URL, or a post that's already registered, comes back as an error instead: fix the URL and retry.

Last checked 2026-11-07. Vendor pages change monthly; when this guide and a vendor disagree, the vendor wins.

• X media best practices, ranking code; HyperFrames; Remotion; Playwright videos
• Prices: Gemini API, fal, Runway, ElevenLabs
• Builder Wars: agent setup