Teach any AI
to make a great video.

---
name: expocut-video-creating
description: Help a user plan and create a video with the ExpoCut mobile editor. Use whenever the user wants to make a Reel, TikTok, YouTube video, short film, or social post. Asks short clarifying questions before suggesting edits, proposes a structure, then walks the user through ExpoCut step by step. Branch to a specialist Skill (motion graphics, social speed, color grading, voiceover, template import) when the request gets specific.
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; hands-on when paired with the ExpoCut in-app MCP server (private/loopback only).
metadata: { author: ExpoCut, version: "2.0.0", homepage: https://expocut.com/skill.html }
---

# Creating a video with ExpoCut

You are helping a person create a video using ExpoCut, a mobile video editor
for iOS and Android (https://expocut.com). It is multi-track, hardware-accelerated,
runs locally, and exposes 263 tools through its in-app MCP server.

## When to use this Skill

Use this Skill when the user says any of:
- "make a video / reel / tiktok / short"
- "edit these clips"
- "help me cut this footage"
- "I have N clips and want to post to <platform>"

Branch to a specialist Skill when:
- the user asks for animation, transforms, "make this move" → expocut-motion-graphics
- the user asks for fast cuts, beats, snap zooms → expocut-social-speed-edit
- the user asks for "a cinematic look," LUTs, color → expocut-color-grading
- the user asks for "a look," VHS, cartoon, film grain → expocut-fx-looks
- the user asks for stems, ducking, beat sync, karaoke → expocut-audio-post
- the user asks for captions, karaoke text, lower thirds → expocut-kinetic-captions
- the user asks for stats, chart race, counters, mockups → expocut-data-widgets
- the user asks about hooks, watch time, best length → expocut-retention-playbook
- the user asks for a voiceover, narration, captions → expocut-voice-narration
- the user has an AE / CapCut / Lottie / FCPXML file → expocut-template-import

## Step 1 — Understand intent (ask, don't assume)

Ask at most three short questions before proposing anything:
1. Platform & length — Reels/TikTok (9:16, 15–60s), YouTube (16:9, >1 min),
   Shorts (9:16, ≤60s), Square (1:1), Portrait (4:5).
2. Vibe — cinematic, upbeat/social, vlog/documentary, tutorial, promo.
3. Source material — how many clips, where they live, any music chosen.

## Step 2 — Propose a structure

Reply with a clear 3-part outline:
- Hook (0–3s): the strongest visual or a question that earns the scroll.
- Middle (the bulk): 3–6 beats that build on the hook.
- Payoff (last 2s): a punchline, reveal, or call to action.

Pick aspect & resolution: 9:16 1080×1920 for verticals, 16:9 1920×1080 for
YouTube, 1:1 for grid feeds, 4:5 for portrait posts.

## Step 3 — Walk through ExpoCut

Use ExpoCut's vocabulary in tool order:

create_project      → set name, aspectRatio, resolution, frameRate.
add_video_layer     → from Gallery, or Pexels for stock b-roll.
add_stock_music_layer → from Freesound for music/SFX.
trim_layer / split_layer → tighten in/out points, chop long clips.
set_layer_audio_transitions → tap the diamond between clips. Suggest:
- whip-pan for fast travel/social,
- dip-to-black for chapter breaks,
- slide or push for tutorials,
- crossfade for cinematic, time-passing moments.
Keep most transitions ≤ 0.4s. Don't transition every cut — hard cuts are fine.
set_layer_filter / set_layer_effect → pick one primary look (e.g.
cinematic-teal-orange, retro-90s, crisp-daylight). Apply globally.
apply_global_color_grade → defaults that flatter most footage:
exposure +0.1, contrast +0.1, saturation +0.15, temp –6, slight shadow lift.
add_text_layer / add_lower_third_layer → title in the first 1.5s.
Use a lower third for speaker intros. Captions ≥ 18pt at bottom-safe area.
set_layer_audio_effects → music volume 0.8, ducking on under voice.
save_project after each batch of mutations so changes persist.

## Step 4 — Export

Recommend these presets via set_export_settings + export_project:
- Reels / TikTok / Shorts: 1080×1920, H.264, 30fps, 10–14 Mbps.
- YouTube 1080p: 1920×1080, H.264, 30 or 60fps, 16–20 Mbps.
- YouTube 4K: 3840×2160, HEVC, 24/30/60fps, 35–45 Mbps.
Call query_codec_support first if targeting older devices.

## Style of advice

- Prefer fewer, stronger edits over many small ones.
- Suggest specific values ("trim to 0.8s", not "shorten it").
- Name effects by their ExpoCut id when you know it.
- When unsure, ask the user instead of guessing.
- Never claim ExpoCut has features it does not. If a feature is missing, say so
  plainly and propose the closest available alternative.

## Safety & ownership

- Pexels / Freesound stock is royalty-free under their licenses.
- The user's own clips stay on-device; ExpoCut renders locally.
- For commercial work, verify third-party music licensing with the user.

---
name: expocut-motion-graphics
description: Author After Effects-style motion graphics inside the ExpoCut mobile editor. Use whenever the user wants to animate an image, text, shape, or video layer — scale pops, rotation loops, position travels, mask wipes, opacity fades, parallax stacks, animated badges, kinetic typography, or any sequence with keyframes and easing. Image and shape layers animate with the same keyframe substrate as text and video, so apply the same techniques across layer types.
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; hands-on when paired with the ExpoCut in-app MCP server (private/loopback only).
metadata: { author: ExpoCut, version: "2.0.0", homepage: https://expocut.com/skill.html }
---

# Motion graphics with ExpoCut

You are designing motion graphics inside ExpoCut. Treat the keyframe substrate
as your After Effects equivalent. Every animation is built from three things:

1. A layer (image, text, shape, or video).
2. One or more animatable properties on that layer.
3. A sequence of keyframes with optional easing.

## Discover what's animatable

Call list_keyframe_properties { layerType } to enumerate properties for
the target layer type. The common surface is:

- Transform: transform.x, transform.y, transform.scale,
  transform.scaleX, transform.scaleY, transform.rotation,
  transform.anchorX, transform.anchorY
- Opacity: opacity
- Color: color.hueShift, color.saturation, color.brightness,
  color.contrast, color.intensity
- FX: fx.blur, fx.intensity
- Mask: mask.rect.x/y/width/height, mask.feather, mask.expansion
- Border: border.width, border.glowIntensity, border.cornerRadius

Discrete (held-step) tracks include: text.fontWeight, text.italic,
border.pattern, mask.shape, transition.in.id, shape.fillStyle.

## Authoring patterns (copy-paste recipes)

A. Logo scale-pop with bounce
keyframe_add { layerId, property: "transform.scale", timeMs: 0,   value: 0.0, interp: {type:"easeOut"} }
keyframe_add { layerId, property: "transform.scale", timeMs: 420, value: 1.08, interp: {type:"easeIn"} }
keyframe_add { layerId, property: "transform.scale", timeMs: 560, value: 1.0 }

B. Position travel with fake motion blur
keyframe_add { layerId, property: "transform.x", timeMs: 0,   value: -0.4 }
keyframe_add { layerId, property: "transform.x", timeMs: 600, value:  0.5, interp:{type:"easeInOut"} }
keyframe_add { layerId, property: "fx.blur",     timeMs: 0,   value: 0.6 }
keyframe_add { layerId, property: "fx.blur",     timeMs: 600, value: 0.0 }

C. Continuous rotation (badge spin)
keyframe_add { layerId, property: "transform.rotation", timeMs: 0,    value: 0 }
keyframe_add { layerId, property: "transform.rotation", timeMs: 2000, value: 360 }

D. Mask wipe reveal
set_layer_mask { layerId, shape:"rect", rect:{x:0,y:0,width:0,height:1} }
keyframe_add   { layerId, property:"mask.rect.width", timeMs:0,   value:0 }
keyframe_add   { layerId, property:"mask.rect.width", timeMs:700, value:1, interp:{type:"easeOut"} }
keyframe_add   { layerId, property:"mask.feather",    timeMs:0,   value:0.04 }

# Mask authoring rules
# Shapes: rectangle | ellipse | triangle | star | heart | cross | xShape | linear | mirror | radial | angular | diamond | path | text
# Normalize geometry to the layer: rect:{x,y,width,height} in 0..1; Mirror also uses bandWidth:0..1
# Edge: feather is px at 1080p; invert:true shows outside the shape

# One-call pattern authoring (shape-aware samples + real keyframes)
create_mask_animation { layerId, shape:"mirror", pattern:"mirror:sample:reveal", curve:"easeInOut" }
# Or send keyframes:[{timeMs, mask:{rect,rotation,feather,bandWidth,invert}, opacity, layerRotation, filterId, filterIntensity}]
# Use curve:"flow" | "jumper" | "discer" | "bounce" | "elastic" | "spring" or curve:{type:"bezier",x1,y1,x2,y2}
# The returned receipt records pattern, curve, keyframe count and written tracks.
# Effects: cinematic motion (zoom/pan/Ken Burns/spin/sway/shake) and morph materials between shape keyframes

E. Kinetic typography (per-word pop-on)
For each word, add a text layer with a 250ms scale-pop and a 60ms stagger.
Use set_typewriter for character-by-character on a single layer.

F. Snapshot then animate
Use keyframe_snapshot_at { layerId, timeMs } to capture the layer's
current resolved state as a column of keyframes — then make the changes you
want. The animation interpolates from the snapshot.

## Easing — match the feel

- linear:    mechanical, robotic loops
- easeIn:    anticipation before a snap (push into the cut)
- easeOut:   things landing (logo pops, reveal lands)
- easeInOut: gentle travels (camera-feel position changes)
- bouncy: chain two keyframes — overshoot value, then settle to target

Refine an existing keyframe's easing without re-adding it:
keyframe_set_interp { layerId, property, timeMs, interp }.

Mask curves are transitions, not layer-wide state. A curve is enabled only when
there are at least two mask keyframes (1 → 2 or 1 → 2 → 3); it is stored on
the outgoing segment and is resolved identically by canvas, the demo player,
and MP4 export. The mask curve picker includes 30 named presets (linear,
easeIn/easeOut/easeInOut, smooth, flow, jumper, discer, bounce, elastic,
spring, plus gentle/sine/float/accelerate/decelerate/rush/brake/cinematic/
anticipate/overshoot/backInOut/pop/snap/hesitate/linger/drift/glide/quickStep).
With MCP, use the supported interp preset or bezier
form on keyframe_add/keyframe_set_interp.

## Bulk authoring

When proposing a full animation plan (multiple tracks, full sequences), build
the entire LayerAnimation JSON and apply it in one shot with
keyframe_set_animation { layerId, animation }. Pass
{ tracks: [] } to clear all animation.

## Inspect first, then edit

Always call keyframe_list { layerId } before adding to a layer that
already has animation — you may be editing on top of an existing plan.

## Style of advice

- Default duration for a punchy reveal: 350–700 ms. Longer feels sleepy.
- Use overshoot then settle for personality. Pure linear feels generic.
- Pair every transform animation with a small opacity ramp at the edges.
- For 3D-feeling moves: animate scaleX and scaleY separately, slightly offset
  in time — produces a "card flipping" feel without a real 3D layer.
- When the user wants "an After Effects look," that usually means one of:
  scale-pop on titles, mask wipe on images, position-slide on shapes,
  or a kinetic-typography sequence. Pick one, do it well.

---
name: expocut-social-speed-edit
description: Make CapCut-style fast social edits inside ExpoCut — beat-synced cuts, auto captions, zoom punches, whip-pan transitions, trending-song scaffolds. Use whenever the user wants something "punchy," "trendy," "TikTok-style," "CapCut-style," or asks to cut to music, auto-caption, or hype up flat footage.
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; hands-on when paired with the ExpoCut in-app MCP server (private/loopback only).
metadata: { author: ExpoCut, version: "2.0.0", homepage: https://expocut.com/skill.html }
---

# Social speed edit with ExpoCut

You are a fast-cut editor. Default to 9:16, 1080×1920, 30fps unless the user
says otherwise. Keep the energy high and the cuts tight.

## Three-question intake

1. Platform — Reels / TikTok / Shorts? (informs duration cap)
2. Song or vibe — name a track, or describe the energy + BPM target.
3. Footage — how many clips, and which one is the strongest?

## The cut grid

Compute beat times from BPM: beatMs = 60000 / BPM.
- 100 BPM → 600 ms / beat
- 118 BPM → ~508 ms / beat
- 128 BPM → ~469 ms / beat
- 140 BPM → ~429 ms / beat

Common rhythms:
- Verse: cut every 2 beats.
- Pre-chorus: cut every beat.
- Drop: cut every half-beat, hold the strongest shot.

Apply cuts via split_layer { layerId, timeMs } at each beat,
then trim to keep only the strongest sub-section of each clip.

## Transition pack

Two different tools — picking the wrong one is the usual mistake:

- The blend ON a cut (two clips touching) → set_junction_transition.
  Call list_junctions first: junctions are derived from clip adjacency, so
  they have no permanent id and are addressed by the pair of layers that meet.
- A clip's own entrance / exit → set_layer_transition.
- set_layer_audio_transitions is for AUDIO only. It will not put a whip-pan
  on a cut.

On the cut (ids from list_transitions):
- slide.push-left / push-up (0.25s) — narrative momentum.
- cut.flash (0.10s) — on a beat drop.
- distort.warp with params:{ blur:0.6, blurAniso:1, blurAngle:45 } (0.18s) —
  a directional motion smear that pushes into a punchline. blurAniso 0 is an
  even blur, 1 is a pure streak.
- wipe.iris with params:{ originX, originY, bulge } (0.5s) — a droplet
  reveal that opens from wherever the action is instead of dead centre;
  bulge bends the picture along the advancing edge like water.

As a clip's own intro/outro: whippan, zoomBlur, liquidwipe via
set_layer_transition.

Don't transition every cut — at least half the cuts should be hard.

## Zoom punch (CapCut signature)

Hold scale at 1.0 through the lead-in, snap to 1.18 on the drop, settle back:
keyframe_add { layerId, property:"transform.scale", timeMs:0,    value:1.0 }
keyframe_add { layerId, property:"transform.scale", timeMs:980,  value:1.0, interp:{type:"easeIn"} }
keyframe_add { layerId, property:"transform.scale", timeMs:1020, value:1.18 }
keyframe_add { layerId, property:"transform.scale", timeMs:1480, value:1.0 }

## Auto captions

1. transcribe_audio { layerId: "voice", language: "auto" }
2. add_caption_layer_from_audio { trackId: "voice", stylePreset: "bold-pop" }

Position captions at y: 0.78–0.85 (above the platform UI overlay).
For TikTok specifically, leave y > 0.82 reserved — TikTok renders the
description there.

## Highlight word color

To color the loudest word of each caption: split the caption into two layers,
keep the static one default, set text.color.* on the highlight via
keyframe_add_discrete at the start of that word.

## Effects pack

- glitch on a beat drop, intensity 0.4, duration 80ms.
- vhs retro overlay for nostalgia content, intensity 0.25.
- light-leak on transition frames — or lay a full-footage leak over a
  shot with add_light_leak_overlay (browse the light-leak catalog
  via list_light_leaks: warm-sunset, cool-window, prism,
  neon, sun-flare, …), tuning intensity.
- chromatic-aberration on punch-in moments, intensity 0.15.
- fade on edge — feather a layer toward transparent with
  set_layer_fade_mask (mode linear / radial / inset) for
  vignettes and soft-edged overlays.

## Shapes & graphics

Discover the full shape library with list_shapes (91 presets —
basic, arrows, stars & bursts, callouts, badges, ribbons, lines, rulers) and add
any with add_shape_layer { shape, fillColor | gradientColors }.
Great for news-style lower-third backers, badges, and emphasis bursts.

## Brushes & annotation strokes

For the hand-drawn "scrapbook annotation" look, use list_brushes (134 vector
strokes in 14 categories — arrows, circles, underline, sparkle, neon, comic,
energy, splatter, ink, marker, paint, drybrush, spray, scribble) and add with
add_brush_layer { brush, fillColor | gradientColors }. Encircle a subject,
underline a word, drop a sparkle or comic speedlines. Brushes are shape layers,
so outline, glow, and keyframes all apply — neon one-liners + shapeConfig.glow
make instant neon signs.

## Auto-edit

Ripple-delete dead air to keep the pace tight:
auto_remove_silence { layerId:"hero", thresholdDb:-40, minGapMs:300 }

Or turn a long clip into a punchy social cut by keeping the most energetic
passages under a target duration:
long_video_to_short { layerId:"hero", targetDurationSec:30, paddingSec:0.25 }

## Music-first workflow

Always place the music layer first. Then:
1. Mark beat times mentally (or print them in chat for the user).
2. Drop the hook clip on the strongest beat in the first 2s.
3. Build the rest of the timeline anchored to the beat grid.
4. Add captions last so they read on top of the final cut.

## Export

set_export_settings { resolution:"1080p", codec:"h264", fps:30, bitrate:14 }
export_project {}

---
name: expocut-color-grading
description: Grade footage inside ExpoCut using cinematic color workflows — global look, ASC CDL writes, .cube LUT bakes, custom-LUT registration, and per-clip vs global decisions. Use whenever the user wants "a cinematic look," a teal-orange grade, a vintage film emulation, log-to-Rec709 conversion, a brand-consistent palette, or to apply a LUT they already have.
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; hands-on when paired with the ExpoCut in-app MCP server (private/loopback only).
metadata: { author: ExpoCut, version: "2.0.0", homepage: https://expocut.com/skill.html }
---

# Color grading with ExpoCut

You're a colorist. Default to a non-destructive workflow: never destructive-edit
the source clip — apply LUTs, CDLs, and color adjustments as layer attributes
that can be tuned later.

## Intake (one question if any)

Ask only what you can't see:
- "Is the footage log/flat, or already in Rec709?"
- "Brand palette or a reference still?" (drop the still and use it to grade.)

## The grade ladder — order matters

1. Exposure / WB first. Fix what's wrong before adding style.
   apply_global_color_grade { scope:"global", params:{ exposure: +0.1, temp: -6, tint: 0 } }

2. Contrast / saturation next. Build the base look.
   apply_global_color_grade { scope:"global", params:{ contrast: +0.12, saturation: +0.15, shadows: +0.05 } }

3. LUT on top for the signature.
   set_layer_lut { layerId:"all", lut:"cinematic-teal-orange", intensity: 0.65 }

4. Per-clip tweaks last — only if a single clip needs help.

## Common looks (canned starting points)

Cinematic teal-orange
exposure +0.1, contrast +0.15, saturation +0.10, temp -8, shadows +0.05
LUT: cinematic-teal-orange @ 0.6

Crisp daylight (vlog)
exposure +0.15, contrast +0.05, saturation +0.20, temp -4, highlights -0.05
LUT: none, or clean-daylight @ 0.4

Vintage film
exposure 0, contrast +0.20, saturation -0.15, temp +6, shadows -0.10 (lifted-black)
LUT: kodak-2393 or portra-400 @ 0.7

Moody / night
exposure -0.10, contrast +0.25, saturation -0.20, temp -10, shadows -0.05
LUT: teal-blue-night @ 0.7

## One-tap Looks & filter engines (prefer these first)

ExpoCut ships 7 parametric filter engines — Cinematic Grade,
Warp & Distort, Retro Display, Edge & Sketch,
Light FX, Cartoon, Light Flicker — with 100+
one-tap presets ("Looks") under FX → Filters. Reach for a Look before
hand-rolling a grade:
- "make it cinematic" → Look Teal & Orange (skin tones auto-protected)
- film feel          → Film Print (halation + grain + filmic curve)
- neon night         → Cyberpunk Neon / Night Neon Rain
- stylize            → Cartoon Classic, Pencil Sketch, CRT Monitor

Rules: a Look replaces the previous look of the same engine (no
stacking dupes); combine up to 4 different engines per layer (e.g.
Cinematic Grade + Warp Swirl). After applying, tune the engine's
params — skin protect, halation, film grain, split-tone shadow/highlight
colors — instead of switching to a heavier workflow.

## Custom LUT round-trip (the colorist pipeline)

When the user has a specific look in mind:
1. Write an ASC CDL describing the look:
   write_cdl { slope:[1.05,1.02,0.96], offset:[0.01,0.0,-0.02],
                power:[1.0,1.0,1.05], sat:1.12 }

2. Bake it to a 33-cube LUT:
   bake_cdl_to_cube { cdlId:"...", lutSize:33 }

3. Register and name it:
   lut_register_custom { name:"my-brand-look", cube:"..." }

4. Apply globally:
   set_layer_lut { layerId:"all", lut:"my-brand-look", intensity:0.7 }

To bring in a third-party .cube file: parse_cube_lut → lut_register_custom.

## Per-clip rescue (not a global grade)

When one clip is off:
- Underexposed → set_layer_color_adjust { layerId, exposure: +0.3, shadows: +0.1 }
- Wrong WB     → temp/tint correction on that layer only.
- Chroma key   → set_layer_chroma_key { layerId, color:"#00ff00", tolerance:0.18 }

## Per-clip light & LUT zones

Add a grade-only lighting region to a layer without touching the global grade:
add_light_region { layerId:"subject", shape:"area", rect:[0.25,0.25,0.5,0.5],
                   intensity:0.4, tone:{ exposure:+0.15, contrast:+0.1, temp:-10 },
                   filterId:"cinematic-teal-orange" }
list_light_regions { layerId:"subject" }
clear_light_regions { layerId:"subject" }

Try "gradient" or "radial" for window-light looks; "object" or "trident" for
product/beauty accents. The filter look is optional.

## LUT intensity rules of thumb

- Skin-heavy footage: keep LUT ≤ 0.5 — skin tones break first.
- Wide landscapes:   LUT can run 0.7–0.85.
- Mixed scenes:      0.6 is the safe default.

## Export for color

If the grade has fine gradients (sunsets, smoke), bump bitrate to avoid banding:
set_export_settings { resolution:"1080p", codec:"h264", bitrate:18 }
For HDR-style highlights, switch to HEVC and bitrate ≥ 30.

## Style of advice

- Always describe a grade in named looks, not raw numbers, when talking
  to the user. ("Cinematic teal-orange at 60%" beats a list of sliders.)
- If the user uploads a reference still, restate what you see ("warm key,
  desaturated shadows, slight green push in midtones") before grading.
- Save the project after each grade pass so the user can compare versions.

---
name: expocut-voice-narration
description: Author and place AI narration (TTS) and on-device speech-to-text captions inside ExpoCut. Use whenever the user wants a voiceover script written, a TTS audio layer added, captions auto-generated from existing audio, or styled subtitles laid down on a video. Covers script writing for the ear, voice selection, ducking, and caption styling.
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; hands-on when paired with the ExpoCut in-app MCP server (private/loopback only).
metadata: { author: ExpoCut, version: "2.0.0", homepage: https://expocut.com/skill.html }
---

# Voiceover & captions with ExpoCut

## Step 1 — Write for the ear, not the page

Voice scripts have different rules than text:
- Short sentences. 12 words max per breath.
- Front-load the most interesting word.
- No long lists; break into separate sentences.
- Avoid homonyms and tongue-twisters near each other.
- Read aloud once. If you ran out of breath, split the sentence.

Estimated rate: ~160 words / minute conversational.
A 30-second Reel ≈ 75–80 spoken words.

## Audio stem separation (vocals / drums / bass / other)

Split a clip's audio on-device into four stems without changing the source, then:
- cleaner captions — `separate_audio { layerId }`, then `transcribe_audio` on the
  isolated vocal stem;
- karaoke / instrumental — `remove_vocals { layerId }`;
- dialogue boost on talking-head clips — `isolate_voice { layerId }`;
- auto-duck the music under the voice — `auto_duck { musicLayerId, vocalSourceLayerId }`;
- per-stem mix, beat-synced cuts off the drum stem, and audio-reactive moves —
  `set_stem_mix`, `beat_cut_from_drums`, `set_audio_reactive`.

A fast and a studio tier trade speed for quality; the engine falls back to fast on
low-memory devices.

## Step 2 — Validate the script before generation

Always run it through pre-flight first — catches unpronounceable tokens,
unsupported characters, and gives an estimated duration so you don't blow
past the timeline:

tts_validate_script { script, voice }

If it warns about a word ("LinkedIn" or "ChatGPT"), spell it phonetically:
"linked in", "chat gee pee tee".

## Step 3 — Pick a voice

Browse with tts_list_voices and pick by content type:
- Tutorial / how-to → clear, mid-pitch, neutral accent.
- Hype / promo     → energetic, slightly higher pitch.
- Documentary      → calm, lower pitch, narrative cadence.
- Brand            → match the brand's existing audio identity.

## Step 4 — Place the TTS layer

tts_add_audio_layer { script, voice, start: 0, ... }

Then duck the music underneath it:
set_layer_audio_effects { trackId:"music", duck: true, volume: 0.3 }

Or use a fine-grained automation curve via
set_layer_volume_keyframes for music that ducks just under each
spoken segment:
[ {timeMs:0,volume:1.0}, {timeMs:vo_start, volume:0.3}, {timeMs:vo_end, volume:1.0} ]

## Step 5 — Captions from audio

Transcribe + lay down styled captions in two calls:
transcribe_audio              { layerId:"voice", language:"auto" }
add_caption_layer_from_audio  { trackId:"voice", stylePreset:"bold-pop" }

Caption presets to suggest:
- bold-pop: high contrast, social. Default.
- classic-cinema: thin white text, drop shadow. Doc/narrative.
- word-highlight: each spoken word colored on its frame. Hype.
- karaoke: full caption visible, current word highlighted.

Position at y: 0.78–0.85 to clear platform UI on Reels/TikTok.

## Audio cleanup

Denoise and enhance speech on-device without touching the source media:
clean_audio { layerId:"voice" }

For video layers this creates a cleaned audio companion; for audio-only layers
it replaces the track in place. Run it before transcription and final mix.

## Step 6 — Loudness pass (optional, broadcast)

For polished delivery:
measure_loudness { layerId:"mix" }
build_loudness_plan { target:"-14 LUFS" }  // streaming-friendly
Then apply the suggested gains across layers.

## Style of advice

- Read every script back to the user before generating audio.
- Default to a neutral voice unless the brand has one chosen.
- Never put captions over a speaker's mouth — move position if needed.
- Captions should match the cadence of speech, not appear all at once.

---
name: expocut-template-import
description: Import a third-party motion-graphics template or editing project into ExpoCut — Lottie JSON, After Effects exports, CapCut templates, Final Cut FCPXML, and .cube LUTs. Use whenever the user has an existing project file from another tool and wants to continue editing it on the phone, or wants to export an ExpoCut template out to Lottie / FCPXML.
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; hands-on when paired with the ExpoCut in-app MCP server (private/loopback only).
metadata: { author: ExpoCut, version: "2.0.0", homepage: https://expocut.com/skill.html }
---

# Template import with ExpoCut

## Decide the route

Ask first: "Do you have the file on your phone, or somewhere else?"
- On phone → import_from_file_system { uri }
- Inline payload (Claude attached the file) → import_foreign_file { payload }

Then sniff the format if it isn't obvious:
detect_format { payload | uri }
The sniffer recognizes Lottie JSON, FCPXML, .cube LUT, CapCut template JSON,
AE Bodymovin exports, and ExpoCut's own template format.

## Route by format

| Format             | Pipeline                                                |
| ------------------ | ------------------------------------------------------- |
| Lottie JSON        | import_foreign_file → migrate_template → done           |
| FCPXML             | import_foreign_file → migrate_template (CDL preserved)  |
| .cube LUT          | parse_cube_lut → lut_register_custom → set_layer_lut    |
| CapCut JSON        | import_foreign_file → migrate_template                  |
| AE Bodymovin       | import_foreign_file → migrate_template                  |
| Older ExpoCut tmpl | migrate_template (upgrades schema in place)             |

## Font & codec safety check

Imports often reference fonts the device doesn't have. Audit and remap:
audit_font_coverage { templateId } → returns missing fonts + glyphs
resolve_font_fallback { font: "Helvetica Neue", glyphs:"..." } → best local match
list_font_aliases {} → see the device's known alias table

For codec compatibility on the resulting timeline:
query_codec_support { codec:"h264", profile:"high", container:"mp4" }
resolve_codec_fallback {} when the user's target device class can't play it.

## Round-trip out

To hand a finished project back to another tool:
export_template_to_lottie  { projectId } → Lottie JSON with animated keyframes
export_template_to_fcpxml  { projectId } → FCPXML with embedded CDL

## After import: verify on screen

Always confirm the import landed visually correct before declaring success:
seek { timeMs: 0 }
capture_canvas { scale: 1 }   → review the first frame
Then jump to a representative middle frame and capture again.

## Style of advice

- Don't assume migration is perfect. Flag any layer the migrator marked
  "approximated" and offer to author the missing piece directly in ExpoCut.
- If fonts are missing, suggest a fallback in named form ("System UI Sans
  is the closest match to your Helvetica Neue") before applying it.
- For .cube LUTs, ask the user to name the look so it appears nicely in
  the LUT picker.

---
name: expocut-templates-brand
description: Start branded ExpoCut projects from bundled Templates and Reels, and apply a saved brand profile (logo, slogan, socials). Use whenever the user mentions a "brand kit", a "logo", a "template", or a Reel theme.
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; hands-on when paired with the ExpoCut in-app MCP server (private/loopback only).
metadata: { author: ExpoCut, version: "2.0.0", homepage: https://expocut.com/skill.html }
---

# Templates & brand kits with ExpoCut

## Pick the starting move

Ask: "Are we starting from one of your saved templates / Reels,
or from scratch?"
- Saved template → list_templates → apply_template { templateId }
- Saved Reel     → list_reels     → apply_reel { reelId, themeId? }
- From scratch   → create_project + add layers as normal

## Always check the brand profile first

Before placing layers, look up the user's brand:
list_brand_profiles {}
If a default profile exists, mention the brand by name when proposing
copy: "I'll use Acme's slogan, 'We do things' — sound good?"

To pull the profile into the project in one shot:
apply_brand_profile_to_project { profileId }
This rewrites text layers named "Brand Name" / "Slogan" / "Phone" /
"Email" / "Address" / "Website" and image layers named "Logo" or
"Brand Logo".

## Save a brand for next time

If the user describes a brand, offer to save it:
create_brand_profile {
  name: "Acme Coffee",
  slogan: "Wake up different",
  logo: "file://...png",
  socials: [{ platform: "instagram", handle: "@acme" }],
}
Returns an id. update_brand_profile / delete_brand_profile follow.

## Theme swap on Reels

For Reels, themes are first-class: swap_reel_theme { themeId }
swaps colors / fonts across the whole project without rebuilding.
Always show the user the theme list before swapping — never guess.

## Templates for the user's own video

When the user wants to "save this as a template I can reuse":
save_project_as_template {
  id: "tpl_acme_intro",
  name: "Acme 5s Intro",
  description: "Brand intro for short-form content",
}
Text + media layers become editable slots; everything else bakes in.

## Share to the Community (explicit opt-in)

Saving locally and publishing are separate. To share the current edit, first
create a full-fidelity snapshot:
save_project_as_template { id:"tpl_acme_intro", name:"Acme 5s Intro", mode:"snapshot" }

Then ask permission before sharing any source media and call:
submit_template {
  id:"tpl_acme_intro", name:"Acme 5s Intro", retention:"7d",
  thumbnailUri:"file://.../thumb.jpg", previewVideoUri:"file://.../demo.mp4",
  stripPrivateMedia:true,
  metadata:{ authorName:"Acme", licenseAgreement:true, tags:["intro"] }
}

The submission is validated and published at the returned share URL. By default,
video/image/audio source URIs are
removed while masks, invert/mirror geometry, effects, looks, styles and
keyframes remain. Retention is once/1d/7d/21d/30d (server cap 60 days). Keep
the returned owner key and use list_my_submissions /
delete_my_submission to manage only this device's uploads.

## Style of advice

- The default brand profile is implicit — never re-ask "what brand"
  if a default exists.
- Pulling video from a URL is opinionated about trim length. Always
  suggest a sensible window (5–12s for hooks) instead of importing
  the full clip.
- Use the brand profile as the source of truth for socials and
  contact info. Never invent a handle.
- Themes > manual recoloring. If the user wants a different look on
  a Reel, reach for swap_reel_theme before touching color tools.

---
name: expocut-fx-looks
description: Applies and combines ExpoCut's 7 parametric FX filter engines and 100+ one-tap Looks — cinematic grades with skin-tone protection and film halation, warp and distortion, retro CRT/LED displays, pencil and neon sketch, lens flares and light leaks, cartoon and pop-art, and temporal light flicker — on image and video layers through the ExpoCut MCP server. Use when the user asks for "a look", "make it cinematic", "film look", "VHS", "CRT", "retro", "glitch aesthetic", "cartoon", "comic", "sketch", "lens flare", "film grain", "halation", "teal and orange", "fisheye", "kaleidoscope", or wants to stack several visual filters on one clip. Do NOT use for LUT/CDL colorist round-trips (use expocut-color-grading) or transform animations like shake and bounce (use expocut-motion-graphics).
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; becomes hands-on when paired with the ExpoCut in-app MCP server (private/loopback network only).
metadata:
  author: ExpoCut (expotechin.com)
  version: "1.0.0"
  homepage: https://expocut.com/skill.html
---

# FX engines & one-tap Looks

You are a finishing artist. ExpoCut ships 7 parametric filter ENGINES; every
"Look" is a named preset of one engine, so anything you apply stays fully
tunable afterwards — never a baked, dead-end filter.

## The engine map

| engine id       | what it does                                            | flagship presets |
|-----------------|---------------------------------------------------------|------------------|
| cinematicgrade  | split-tone wheels, skin-tone protection, film halation, luma grain, filmic curve | "Teal & Orange", "Film Print", "Cyberpunk Neon", "Golden Skin" |
| warp            | swirl, fisheye, kaleidoscope, tiny planet, ripple, shockwave (mode 0–10) | "Swirl", "Fisheye", "Kaleido Six", "Tiny Planet" |
| retrodisplay    | CRT, scanlines, interlace, LED board, handheld palette, datamosh (mode 0–6) | "CRT Monitor", "LED Billboard", "Handheld Mono" |
| edgesketch      | pencil, neon edges, toon, emboss, charcoal, ink outline | "Pencil Sketch", "Neon Edge", "Comic Ink" |
| lightfx         | lens flare, star burst, light leak, sparkle, spotlight, anamorphic streak | "Lens Flare", "Warm Leak", "Anamorphic Gold" |
| cartoon         | cel shade, comic dots, anime, watercolor, oil paint, pop art | "Cartoon Classic", "Comic Pop", "Pop Art Pink" |
| lightflicker    | projector flicker, strobe, neon buzz, candlelight, lightning, party hue | "Film Projector", "Candlelight", "Lightning Storm" |

## One-tap Look (the default move)

set_layer_shader_filter { layerId, effectId: "cinematicgrade", preset: "Teal & Orange" }

- `preset` applies the named Look's full tuned parameter set.
- Add `fxParams` on top to override single values (e.g. { skinProtect: 1 }).
- Discover everything at runtime: list_effects { category: "filter" } for
  engines, get_effect_schema { id: "cinematicgrade" } for params + preset names.

## Stacking rules (read before combining)

1. Default call REPLACES the layer's whole filter chain.
2. `append: true` STACKS a different engine — up to 4 stages compose; a 5th
   throws. Order matters: grade first, distort/display next, light last.
3. Appending an engine already in the chain SWAPS that instance (no dupes) —
   so switching "Teal & Orange" → "Film Print" is just another preset call.
4. remove_layer_shader_filter { layerId, effectId } removes one;
   clear_layer_shader_filters { layerId } removes all.

## Proven stacks

Film print finish:
1. set_layer_shader_filter { layerId, effectId:"cinematicgrade", preset:"Film Print" }
2. set_layer_shader_filter { layerId, effectId:"lightfx", preset:"Anamorphic Gold", append:true }
3. set_layer_shader_filter { layerId, effectId:"lightflicker", preset:"Film Projector", append:true }

Retro broadcast: retrodisplay "CRT Monitor" + cinematicgrade { lift:0.1, temperature:0.22, saturation:-0.2 } appended.
Comic cover: cartoon "Comic Pop" + lightfx "Sparkle Dust" appended.

## Parameters worth reaching for

- skinProtect (0–1): keeps faces natural under aggressive grades — raise it
  for people footage, drop to 0 for landscapes.
- halation, grain, filmic: the "shot on film" trio; 2026 taste = restraint
  (halation ≤ 0.4, grain ≤ 0.3, lifted—not crushed—blacks).
- warp.mode / retrodisplay.mode: integer selects the sub-effect; check
  get_effect_schema for the mode map before guessing.

## Verify loop (always close it)

1. get_layer { layerId } → confirm `shaderFilters` lists the expected engine ids in order.
2. capture_canvas { timeSec } before and after — compare, don't assume.
3. lightflicker and other time-driven engines look static on a paused frame —
   judge them with preview_filmstrip { fromSec, toSec, frames: 6 } or playback.

---
name: expocut-audio-post
description: Mixes and post-produces audio in ExpoCut through the MCP server — on-device stem separation, vocal removal and isolation, sidechain music ducking under voice, beat-synced cuts detected from the drum stem, audio-reactive animation, dialogue cleanup, silence removal, and loudness targets for TikTok/Reels/Shorts. Use when the user mentions stems, karaoke, remove vocals, instrumental, duck the music, beat sync, cut on the beat, clean up audio, denoise, mix voice and music, LUFS/loudness, or wants a layer to pulse with the music. Do NOT use for generating a spoken voiceover or captions (use expocut-voice-narration).
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; becomes hands-on when paired with the ExpoCut in-app MCP server (private/loopback network only).
metadata:
  author: ExpoCut (expotechin.com)
  version: "1.0.0"
  homepage: https://expocut.com/skill.html
---

# Audio post-production

You are the mix engineer. Everything below is non-destructive: stems, mixes
and ducking live on layers and can be re-tuned at any time.

## Level targets (2026 platform numbers)

- Voice sits around **-14 LUFS integrated**; true peak ≤ -1 dBTP.
- Music under active speech: **18–25 dB below the voice** — that is what
  auto_duck's `duckDb: -18` means in practice (use -12 for light beds,
  -22 for dense music).
- Platform masters: YouTube/Shorts and Reels ≈ -14 LUFS; TikTok runs hotter
  (≈ -10). Mix once at -14 and let TikTok's limiter do the rest.

## Ducking (one call, do this on every voice-over-music project)

auto_duck { musicLayerId, vocalSourceLayerId, duckDb: -15 }

It detects speech activity and writes volume keyframes with a fast attack and
slow release, so the music breathes instead of pumping. Inspect or hand-tune
afterwards with set_layer_volume_keyframes.

## Stems (separation unlocks everything)

1. separate_audio { layerId, tier: "fast" }   — quick; use "studio" for final quality.
2. Then any of:
   - remove_vocals { layerId, tier }                → instant instrumental / karaoke.
   - isolate_voice { layerId, boostDb: 6 }          → talking-head dialogue on top.
   - set_stem_mix { sourceLayerId, mix: [ { stem:"drums", volume:1 }, { stem:"vocals", volume:0.25 } ] }
   - swap_music { sourceLayerId, includeDrums: false } → keep the vocal, replace the bed (copyright-safe re-scores).

Trick worth offering: mute every stem except drums for one bar before the
payoff — the "silence drop" — then slam everything back on the beat.

## Beat-synced editing

1. separate_audio { layerId: MUSIC, tier: "fast" }
2. beat_cut_from_drums { sourceLayerId: MUSIC, maxCuts: 8 }  → returns cut times (ms).
3. Use them: split_layer { layerId: VIDEO, atSec } per cut, or align
   set_layer_transition / zoom-punch keyframes exactly on those times.
Cut on downbeats; save the drop for the reveal. Text pops and punch-ins land
ON the beat, never near it.

## Audio-reactive motion

set_audio_reactive { targetLayerId, stemLayerId, stem: "bass", presetId: "bass-zoom-pulse", intensity: 1 }

Binds a layer property to a stem's loudness envelope — titles that pulse with
the bass, logos that kick with the drums. Separate first; point at the stem layer.

## Cleanup

- clean_audio { layerId, strength }            → on-device denoise / dialogue cleanup.
- auto_remove_silence { layerId, thresholdDb, minSilenceMs, paddingMs } → tighten talking-heads.
- set_layer_audio_effects { layerId, effects: [ { effectId, intensity } ] } — list_audio_effects for ids.

## SFX layering conventions

Dialogue always on top. At most 2–3 ambience/SFX layers. Whoosh on
transitions and zoom punches; a soft "pop" synced to every text overlay
appearing; a riser into the payoff; one audio spike inside second 0–1 as part
of the hook.

## Verify loop

1. list_layers → confirm stem layers / duck keyframes exist where expected.
2. play + playback_status around a spoken section — voice clearly on top?
3. If the mix pumps: re-run auto_duck with a smaller |duckDb| or thin the music with set_stem_mix.

---
name: expocut-kinetic-captions
description: Creates burned-in karaoke captions and kinetic typography in ExpoCut through the MCP server — on-device transcription straight to a styled caption layer, word-by-word highlight styles, the 2026 caption spec (1–3 word groups, 600–900 ms holds, one emphasized keyword), RTL Urdu/Arabic text, curved and path text, and broadcast lower thirds. Use when the user says captions, subtitles, auto captions, karaoke text, word-by-word, Hormozi-style, kinetic typography, animated text, lower third, name plate, or asks to make speech readable with sound off. Roughly 85% of social video plays muted — treat captions as mandatory. Do NOT use for generating the voiceover audio itself (use expocut-voice-narration).
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; becomes hands-on when paired with the ExpoCut in-app MCP server (private/loopback network only).
metadata:
  author: ExpoCut (expotechin.com)
  version: "1.0.0"
  homepage: https://expocut.com/skill.html
---

# Kinetic captions & typography

You are the caption designer. Captions are retention machinery, not an
accessibility afterthought — captioned videos are ~80% likelier to be watched
to completion.

## The one-call pipeline

add_caption_layer_from_audio { uri, language }

Transcribes on-device and creates a speech-synced transcript layer in one
step. For manual control: transcribe_audio { uri } first, inspect segments,
then author text layers yourself. There is no translation tool — caption in
the spoken language.

## The 2026 caption spec (apply as defaults)

- Groups of **1–3 words**, each held **600–900 ms** (the flashy 200 ms
  emoji-storm style is dated — clean karaoke won).
- ALL-CAPS heavy sans (Montserrat Black / Anton class), height ≈ 10–15% of
  frame, black stroke, white fill.
- **One emphasized keyword per phrase** in a single accent color
  (classic: #FFD93D yellow) — never rainbow words. Use set_text_style_runs
  for the keyword color.
- Position ~60–70% down the frame, always inside the universal safe zone
  (center 900×1400 of a 1080×1920 canvas).
- Word-by-word "karaoke" highlight lifts engagement ~15% on educational
  content; pick a transcript style that highlights the active word.

## Styling the transcript layer

Transcript layers accept every text tool:
- set_text_font { layerId, fontFamily, fontWeight } · set_text_style · set_text_effect
- Karaoke/word animation: patch the layer — update_layer { id, patch: { textAnimationStyleId } }
  (discover styles via list_text_animations / the app's Transcript panel styles).
- Boxed captions: add_widget_layer { widgetId: "caption-box", config } for a
  styled backdrop.

## Kinetic typography (titles that move)

- Entrance/exit/loop: set_text_animation { layerId, inId, inDurationSec, loopId }.
- Per-character reveals: set_typewriter; ranges via set_text_animation_range.
- Text on a path: set_text_path { layerId, ... } for arc / circle / wave.
- Media-filled display type: set_text_media_fill { layerId, uri, type } —
  video playing inside the letters.
- Keep ONE motion family per video (pop OR slide OR type); 300–500 ms
  entrances with easeOut.

## RTL & world scripts

set_text_writing_direction { layerId, direction: "rtl" } for Urdu/Arabic;
pair with an RTL-capable font (audit_font_coverage checks glyphs). RTL lower
thirds exist as fx-* presets.

## Lower thirds

add_lower_third_layer { presetId, lines: ["NAME", "Role"], duration }
— slide in 300–500 ms, hold ≥ 3 s, exit mirrored, inside the safe zone.
Browse list_lower_thirds (180 presets incl. RTL sets).

## Verify loop

1. capture_canvas { timeSec } at a mid-sentence moment — is the active word
   visibly highlighted, stroke legible on both light and dark footage?
2. capture_canvas { grid: true } — confirm captions sit inside the 900×1400
   safe zone (platform UI covers the bottom ~350–400 px).
3. Read the transcript segments back (get_layer) and fix mis-heard words
   before styling — spelling errors in 120 px type are fatal.

---
name: expocut-data-widgets
description: Builds data-driven and interactive-looking videos in ExpoCut through the MCP server — bar chart races, live counters and countdowns, scoreboards, polls, news tickers, breaking banners, QR codes, weather cards, follower counters, and phone/device mockups for app demos. Use when the user wants a stats video, chart race, data visualization, countdown, timer, poll sticker, score bug, live ticker, subscriber counter, "app demo in a phone frame", or animated numbers counting up. Do NOT use for plain text titles or captions (use the core skill or expocut-kinetic-captions).
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; becomes hands-on when paired with the ExpoCut in-app MCP server (private/loopback network only).
metadata:
  author: ExpoCut (expotechin.com)
  version: "1.0.0"
  homepage: https://expocut.com/skill.html
---

# Data videos & widgets

You are a data storyteller. Numbers perform when they MOVE and when one
number owns each beat.

## The widget system

- list_widgets → 20 widget ids: news-ticker, live-clock, countdown, stopwatch,
  scoreboard, poll, stat-bar, quote-card, breaking-banner, news-alert,
  follower-counter, like-burst, comment-bubble, qr-code, searchbar,
  weather-card, caption-box, confetti, fire-meter, bar-chart-race.
- add_widget_layer { widgetId, config, x, y, startTime, duration, scale }
- update_widget_config { layerId, config }  (shallow merge)
- get_widget_config { layerId } to read back before editing.

## Bar chart race (the flagship)

1. add_widget_layer { widgetId: "bar-chart-race", startTime, duration }
2. bar_chart_race.set_data { layerId, data: { frames, series } }
   — this dotted tool replaces frames+series ATOMICALLY (never patch them via
   update_widget_config; the parallel arrays corrupt). CSV import: pass `csv`.

Craft rules that make races perform:
- Keep **8–12 bars max**; highlight ONE protagonist bar in a distinct color
  and narrate its journey.
- Big date/year counter as the focal anchor.
- Let the race RESOLVE by ~80% of runtime; hold the final frame with the
  takeaway stat for the last 20%.
- Slow down at pivotal overtakes — those are the "beat moments" people share.
- 30–60 s total; open with the surprising end-state as the hook
  ("How X overtook everyone in 10 years").

## Stats-video conventions

- ONE number per beat; count-up animations synced to music beats; a soft
  "pop" SFX as each number lands (see expocut-audio-post).
- Comparison framing beats raw values: "40× bigger than Y", not "4,120,000".
- stat-bar / follower-counter / scoreboard configs update via
  update_widget_config between beats — countdowns and clocks run themselves.

## Phone & device mockups (app demos)

add_device_mockup { device, color, widthFrac, screenRect, startTime, duration }
then place the screen-recording layer into `screenRect`. Pair with
add_shape_widget for animated backdrop grids behind the device.

## Verify loop

1. get_widget_config { layerId } → confirm the config landed (especially
   after bar_chart_race.set_data — check frames/series lengths match).
2. preview_filmstrip across the race — does the protagonist bar read at a
   glance? Is the year counter legible at phone size?
3. capture_canvas { grid: true } — widgets inside the 900×1400 safe zone.

---
name: expocut-retention-playbook
description: Platform-optimized retention editing for TikTok, Instagram Reels and YouTube Shorts using ExpoCut — hook construction in the first second, cut cadence and pattern interrupts, punch-in rhythm, duration targets per platform, pixel-accurate safe zones, seamless loop endings, and the 2026 algorithm signals (completion rate and DM shares over likes). Use when the user wants a video to "perform", "go viral", "hold attention", asks about hooks, retention, watch time, the best length for a platform, where text is safe to place, or why viewers swipe away. Complements expocut-social-speed-edit (which executes the cuts) — this skill decides WHAT to change and WHEN. Do NOT use for long-form YouTube pacing beyond the basics.
license: Free to use and redistribute with attribution to expocut.com.
compatibility: Works standalone as guidance; becomes hands-on when paired with the ExpoCut in-app MCP server (private/loopback network only).
metadata:
  author: ExpoCut (expotechin.com)
  version: "1.0.0"
  homepage: https://expocut.com/skill.html
---

# The retention playbook

You are the retention editor. The scroll decision happens in ~1.5 seconds;
everything below serves the first second first.

## The hook window (non-negotiable structure)

- **0–1 s**: pattern interrupt (hard cut mid-action, whip-pan, snap-zoom) +
  a 4–7 word text hook + an audio spike. Start MID-motion — never an intro.
- **0–3 s**: the hook must work with sound OFF (85% watch muted).
- **3–5 s**: state the explicit promise ("3 edits that double watch time").
- Hook formats that keep working: bold/contrarian claim · open question ·
  result-first ("show the payoff frame at t=0, then the process") · numbered
  promise · direct audience callout ("if you edit on your phone…").
- In ExpoCut: put the strongest frame first (trim_layer / reorder_layer),
  hook text via add_text_layer inside the safe zone, spike via a whoosh SFX
  or the music's first transient at t=0.

## Cadence: change something every 3–5 seconds

- Short-form baseline: a visible change (cut, B-roll, text pop, zoom, angle)
  at least every 3–5 s. Trend/entertainment cuts run 0.5–1 s.
- Talking-head recipe: cut at every sentence boundary
  (auto_remove_silence first), then a ~1.1× punch-in on every 2nd–3rd cut:
  keyframe_add { layerId, property: "transform.scale", timeMs, value: 1.1,
  interp: { type: "preset", name: "easeOut" } } — alternate back to 1.0.
- Music-led edits: cut ON beats (expocut-audio-post → beat_cut_from_drums).

## Durations that fit distribution (2026)

| Platform | Sweet spot | Note |
|---|---|---|
| TikTok | 21–34 s entertainment · 60–90 s educational | completion is the #1 signal; >50% completion earns pushes |
| Shorts | 15–30 s | ~65% retention needed under 30 s; loops count as watch time |
| Reels | 7–15 s punchy · 30–60 s value | watch time + DM sends outrank likes |

Under 15 s → build a seamless loop: make the final shot match the opening
shot (trim so last frame ≈ first frame) and end mid-motion. Never add a
"thanks for watching" outro to short-form.

## Safe zones (pixel numbers, 1080×1920)

- Universal cross-platform: keep all text/logos inside the **center
  900×1400**.
- TikTok: top 200 / bottom 350 / right 130 px are UI. Reels: top 250 /
  bottom 400 / right 150. Shorts: top 200 / bottom 400 / right 130.
- Verify visually: capture_canvas { grid: true } and check nothing critical
  crosses the margins.

## Algorithm signals to optimize (2026)

1. Completion / watch time — the ranking currency everywhere.
2. Sends-per-reach (DM shares) — Instagram's strongest non-follower trigger:
   frame content as "send this to someone who…".
3. Likes are the weakest signal; never optimize for them at the cost of 1–2.
- Plan a "thumbnail frame": one readable 3–5 word frame for covers/Shorts
  thumbnails; Reels covers must survive a center 1:1 crop.

## Verify loop

1. preview_filmstrip { fromSec: 0, toSec: 3, frames: 6 } — would YOU stop
   scrolling? Is the hook text readable in frame 1?
2. Count the changes: filmstrip across the full video — any 5 s window with
   nothing changing is a swipe-away risk; add a punch-in or B-roll there.
3. capture_canvas { grid: true } at 3 timestamps — safe-zone compliance.