Tella

View saved version →

---
name: tella
description: Analyze, edit, and visually verify Tella videos through the Tella MCP. Use for understanding a Tella video or improving it with trims, layouts, overlays, and related timeline edits.
---

# Tella Video Editor

Use the Tella MCP to understand, edit, and verify a video. Match the user's scope; an analysis request does not imply permission to edit.

## Before you start: connect the Tella MCP

This skill drives Tella through its MCP server at `https://api.tella.com/mcp` (Streamable HTTP, OAuth). If no Tella MCP tools such as `get_timeline` are available, connect the server first:

- Claude Code: `claude mcp add --transport http --scope user tella https://api.tella.com/mcp`
- Codex: `codex mcp add tella --url https://api.tella.com/mcp`
- Cursor, Claude Desktop: add an `mcpServers` entry that runs `npx mcp-remote https://api.tella.com/mcp`
- Anything else: any Streamable HTTP MCP client; a personal API key (`tella_pk_…`, created at Settings → API Keys in Tella) works as the bearer token

The first connection opens Tella in the browser to sign in and pick a workspace. The full tool reference is at https://www.tella.com/docs/mcp-server.

## Approach

For a broad understanding of the video, start with `get_timeline` and one or more `get_storyboard` calls. Use `get_video_frame` for an exact still and `get_video_preview` for motion, audio, transitions, or cut continuity. GIF frames are for thumbnails, not analysis. A returned preview URL counts as verification only after its MP4 has actually been opened and reviewed. Inspect only as much as the task and remaining uncertainty require.

Interpret informal editing terms by their intended outcome, not as rigid presets. When a request such as “fully edit,” “auto edit,” or “rough edit” leaves materially different treatments open, inspect the video and present a recommended edit package plus the relevant options: pacing and how much may be cut; layouts, zooms, or cropping; b-roll, text, or media overlays; audio, captions, or chapters; and, when relevant, format such as aspect ratio. Describe what the plan does, never what it leaves out: publishing details such as metadata, thumbnail, caption delivery, or export are a choice to offer when they seem wanted, not a disclaimer. Clarify ambiguous terms such as “overlay,” then ask the user to approve or adjust the scope before the first write. Translate their choices into tools rather than making them design the edit. Treat the approved package as the scope, and reconfirm before materially departing from its intended pacing, duration, or treatment.

Once the scope is clear, implement a coherent, watchable first pass while preserving the video's meaning. Treat detected fillers and silences as edit candidates rather than automatic removals: pauses may communicate thought, reaction, waiting, or visible system behavior. To find and remove retakes, false starts, and other recording mistakes, use the `tella-remove-mistakes` skill. When the user asks to auto cut or tighten a whole recording in one go, use the `tella-auto-cut` skill: it cuts mistakes, fillers and silences without asking first, then cleans up the seams. “For YouTube” signals audience-facing pacing and presentation, not a fixed formula.

Each clip has a base layout, addressed as `layoutId: "base"`: change it with `update_layout`, and use `add_layout` with a time range to change only a section of the clip. Users name layouts by the editor's picker labels, such as “Split Right Overlap”; use the kind and style the tool descriptions give for that label, not the nearest default variant. To lay out a clip automatically, use the `tella-auto-layouts` skill.

For motion graphics (animated text, titles, diagrams, number callouts, screen annotations), load the `tella-motion-design` skill for the shared rules, then the skill for the graphic: `tella-kinetic-type`, `tella-title-cards`, `tella-explainer-graphics`, `tella-data-callouts`, `tella-screen-callouts`, `tella-carousels`, `tella-transitions` or `tella-camera-moves`. For product UI in Tella Motion, use `tella-ui-redraw` (rebuilt screens), `tella-ui-interactions` (UI that acts) or `tella-ui-parallax` (depth from a screenshot).

To plan what to say and show before recording, or to turn a loose take into a script to record again, use the `tella-plan-video` skill. For a launch, promo or feature video, use `tella-launch-video`; for a video from release notes, `tella-changelog-video`.

When the video needs footage only the user can give (a talking intro, a retake, a voiceover, a screen walkthrough, or a new video with no clips yet), hand recording over to them instead of describing where to click: `get_recording_link` returns a `url` that opens their own recorder (the browser, or the Tella Mac or Windows app if they record there) and adds the take as a new clip at the end of the video. For a new video, call `create_video` without `sourceId` first and pass its id. Give the user the URL and ask them to tell you when they're done; you get no signal when the recording finishes. Then find the new clip with `list_clips` and carry on editing. If the clip isn't there yet, it may still be uploading: wait a moment and read again rather than asking them to record twice. If you wrote what they should say, give it to them with the link.

Treat “b-roll” as supporting media that usually belongs in a media-bearing layout, taking over or sharing the main visual area. Use an overlay when the media is intended to float over the primary scene.

When a different format is requested or clearly suits the intended platform, `update_video` dimensions can change the output canvas and aspect ratio—for example, 1080×1920 for a 9:16 mobile video. Uncommon dimensions can be intentional, including Tella’s Auto ratio, so do not normalize them unless the user asks or the target format requires it. Changing dimensions remaps existing layouts rather than changing the source footage, so inspect and adjust the layouts afterward.

For event-driven edits, prefer recorded metadata such as mouse events and transcript timing when available, then inspect the surrounding video before placing effects. Create derivative clips or reels from duplicates rather than repurposing the original. To turn a video into a vertical Short, Reel or TikTok, use the `tella-short` skill.

Resolve the time domain before editing: video-level inspection uses cumulative video playback time; most clip edits use clip-local playback time with cuts applied; `update_clip` cut definitions use raw recording time. Apply cut ranges measured from one playback state together, and re-read the timeline after a cut before calculating more.

After a structural change that affects timing or composition, re-read and inspect the result before placing dependent zooms, overlays, chapters, or thumbnails.

Where a setting exists at video and clip scope, clip values act as overrides or opt-outs from the video default. Inspect existing values and update the narrowest intended scope instead of writing both reflexively.

If a write has an unclear outcome, re-read the current state before retrying; never blindly repeat additive or cutting operations. Some changes process asynchronously, so wait for the rendered result before evaluating them.

When the user wants to watch the video change while you edit it, or before a long run of edits, offer a live preview: `get_live_preview_link` returns a `url` to a player of the editor's preview that shows each saved edit a moment later, without re-rendering. Give the user that URL exactly as returned (its access token is in the `#token=` fragment), or open it yourself if your host can show web pages. Anyone with the link can watch without signing in until `expiresAt` (24 hours), so share it only with the user, and ask for a fresh one after it expires. It is for the user to watch; it does not replace checking your edits with `get_video_frame` and `get_video_preview`.

After editing, re-read the timeline and inspect the affected ranges with the appropriate tools. Iterate until the requested result is present and no obvious problem remains. Report what changed, what the inspection actually verified, and any remaining uncertainty.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-auto-cut
description: Tighten a Tella video in one pass through the Tella MCP. Cuts recording mistakes (false starts, retakes, repeated phrases, abandoned sentences), filler words and silent pauses, then cleans up the gaps and broken seams those cuts leave behind. Use when asked to auto cut, auto edit, clean up, or tighten a recording.
---

# Auto cut a Tella video

Cut the mistakes, the fillers and the silences from every clip, then read the result back and fix what the cuts left behind: pauses that joined across a cut, doubled words and leftover fragments.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

## Scope

Auto cut is a direct action: cut, then report what you did. Don't ask for approval of the mistake list first; the user can restore or adjust afterwards. Ask only when you can't tell which video or clip is meant.

It cuts silent stretches even when something is happening on screen. Pace is the silence mode: `natural` (pauses over 800 ms) unless the user asks for `fast` (500 ms) or `faster` (300 ms). If the user only wants some of the steps ("just the silences"), do only those, but still run the final pass.

Don't change layouts, zooms, overlays or captions.

## Workflow

Work clip by clip; transcripts, word indices and cuts are all per clip. `get_timeline` lists the clips. Before cutting, call `get_clip` on each one and keep its `cuts`, so you can say how to restore it.

On a clip, run the steps one at a time: send a step's call only after the previous call on that clip has returned. Calls on the same clip that run together each return the clip as they saw it, so one call's result can be missing the other's cuts even though both landed.

1. **Mistakes.** Follow steps 1–3 and 5 of the `tella-remove-mistakes` skill, with its rules in [../tella-remove-mistakes/references/mistake-rules.md](../tella-remove-mistakes/references/mistake-rules.md): read the transcript, find the mistakes, and cut them with one `cut_clip_by_transcript` call per clip. Skip its review step (step 4). Its rule still holds: when unsure, leave it in.
2. **Fillers.** `remove_fillers` on each clip.
3. **Silences.** `remove_silences` on each clip with the chosen `mode`. If it answers that the audio analysis is still processing, wait a little and try again, at most a few times; if it still isn't ready, skip silences for that clip, do the final pass anyway and say so in the report.
4. **Final pass.** See below.
5. **Report** per clip: the mistakes cut (time, reason, words), that fillers and silences were removed, the gaps and seams the final pass fixed, and the clip's length before and after. Say how to restore (below).

Mistakes go first because they are the step that needs reading. Fillers and silences can follow in either order: word indices never shift, and `remove_silences` works from the original recording.

## Final pass

`remove_silences` finds pauses in the original recording and ignores the clip's cuts. When a mistake or filler is cut, the pause before it and the pause after it now play back to back. Each was shorter than the threshold, so neither was cut, but together they play as one long gap. The transcript after all cuts is the only place that shows what actually plays.

1. **Re-read the transcript** with `get_transcript` (in windows for long clips, as in the mistakes skill). Times are on the playback timeline, with every cut applied.
2. **Trim long gaps.** For each pair of neighbouring words, the gap is the next word's `startTimeMs` minus the previous word's `endTimeMs`. Where it is longer than the mode's threshold (800 / 500 / 300 ms), cut `{fromMs: previous.endTimeMs + 120, toMs: next.startTimeMs - 120}`, which leaves 120 ms of air next to each word. Treat the gap before the first word and after the last word the same way, keeping 120 ms next to the word. Send every range for a clip in one `cut_clip` call: ranges are resolved against the playback timeline as it was when the call started, so a second call would use shifted times.
3. **Fix broken seams.** Read across each cut and look for what the cuts left:
   - the same word on both sides of a cut ("the the"): cut one of them;
   - one or two stray words stranded between two cuts that no longer belong to either sentence: cut them;
   - leftover words of a mistake that a cut took too little of: cut them.

   Fix these with `cut_clip_by_transcript` on the word indices. Never split a word or pad a range with extra words.

   Cuts only remove words: a word that is already cut is absent from the transcript and no further cut brings it back. If a mistake cut took too much (the sentence lost a word it needs), restore the clip's saved cuts with `update_clip` (see Restoring), redo steps 1–3 with the corrected mistake range, and run the final pass again on the new transcript.
4. **Listen to the risky seams**: mistake and filler cuts, several cuts within a few seconds of each other, and a word that ends right at a cut (it can sound clipped). A cut at a clear pause needs only the transcript re-read and `get_audio_levels`. `get_clip_preview` only returns a URL: download its MP4 (it has the clip's audio), cut each risky seam's range to audio with ffmpeg (`ffmpeg -ss 2 -t 6 -i preview.mp4 -vn -ac 1 -ar 22050 -b:a 48k seam.mp3`), join them into one file and listen to it once with your audio tool (`describe_audio` in the Tella editor). If the listen and the transcript disagree, `get_audio_levels` for those few seconds settles whether the word is whole. If the word isn't needed, cut it whole; if it is, restore and redo as above with that cut one word smaller. Never adjust a cut by milliseconds.

Run the final pass once (twice for a clip you had to restore), then report anything you saw but left alone.

## Restoring

A single cut can't be undone cleanly: a mistake cut merges with the filler and silence cuts next to it. To restore a clip, call `update_clip` with the `cuts` you saved from `get_clip` before starting. `cuts` replaces the clip's whole cut list, and the person may be editing the video by hand while you work: keep any cut in the current `get_clip` that neither you made nor was in the saved list, and send `cuts: []` only when that is the result: the saved list was empty and the current clip has no cuts to keep, or they asked to remove every cut. To redo with different choices, restore and run again.

A cut call that returned the clip succeeded; don't send it again, even when a later result seems to lack its cuts. If a cut call fails or its outcome is unclear, re-read the transcript before retrying: words that were cut are absent from it. When `cut_clip_by_transcript` reports word indices not found, those words are already cut: drop those ranges and send the rest once. Never blindly repeat a cut.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-auto-layouts
description: Lay out a Tella clip automatically through the Tella MCP. Picks a base layout and adds timed layout changes (screen focus, camera cutaways, bubble size changes, punch-ins) where they help the viewer, keeping the clip's camera style and pop-out and preferring the user's Favorite layouts. Use when asked for auto layouts, to lay out or re-layout a clip, or to make a screen-and-camera recording more dynamic.
---

# Auto layouts for a Tella clip

Work out what happens in the clip from its transcript, cursor data and frames. Choose the layout the viewer should see most of the time, and add layout changes only where they make a moment clearer or land harder. Then apply them and check the result.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

## Scope

Auto layouts is a direct action: apply the layouts, then report what you did. Don't ask for approval first; the user can undo or ask for changes. Ask only when you can't tell which clip is meant.

It replaces the clip's existing layout changes. Keep layouts that carry b-roll `media` and plan around them. Don't change cuts, zooms, overlays or captions. Add generated b-roll (`generate_image`, then `add_layout` with `media`) only when the user asks for b-roll.

If the user names a style (product demo, tutorial, presentation, intro/outro only) or gives instructions, those win over everything below.

## Workflow

1. **Read the clip.** `get_timeline` gives the clip's id, playback duration and `layoutSceneType`. `list_layouts` gives its base layout (with `cameraStyle`, `popOut` and `crop`) and its sections. Sections with `followsBase: true` just show the base layout; the others are the current layout changes. The base layout's look is the user's choice: keep its camera style, pop-out, camera shape and crop unless the user asked for a different look. `list_saved_layouts` gives the user's Favorite layouts; only those whose `sceneType` matches the clip's `layoutSceneType` (and, for custom ones, whose `canvasRatio` matches the video) can be used here.
2. **Understand what happens.** `get_transcript` for what is said and when. `get_mouse_events` with `types: ["clicks"]` shows where the screen is being operated. `get_storyboard` on the clip shows what is on screen and when it changes: cover the clip in windows (80 seconds by default, wider for long clips), then narrow down where something changes. Look at a `get_clip_frame` to see which way the speaker faces and what the camera covers. A rendered frame shows the camera as the viewer sees it, mirroring included.
3. **Decide the edit** using the guidance below: the base layout, then a short list of moments that deserve a change, each with a reason.
4. **Apply it.** If the base becomes a favorite, `apply_saved_layout` without a range first. Then one `apply_video_edits` call: `remove_layout` for each old layout change (only sections with `followsBase: false`; a section with `followsBase: true` already shows the base and can't be removed), `update_layout` on `base` if the base should change, then one `add_layout` per change. Give every change that frames the camera the base's `cameraStyle` and `popOut`, because a new layout doesn't inherit them. `apply_video_edits` can't set a crop, so a base with its own crop needs one more step: run `list_layouts` after the batch and, for each new layout that shows the screen and reports a different `crop` from the base, call `update_layout` with the base's `crop`. Changes that use a favorite can't go in the batch: apply each with `apply_saved_layout` and a range afterwards, then give it the base's `cameraStyle`, `popOut` and `crop` with `update_layout` where they differ. A custom favorite (`kind: custom` in `list_layouts`) rejects `cameraStyle`: set the camera's shape with `layout: {kind: "custom", presentation: {shape}}` instead, which keeps its geometry (the shape takes the same value as the base's `cameraStyle`), and send its `crop` in a separate `update_layout`. Times are ms on the clip's playback timeline, the same as the transcript; each change is at least 200 ms long.
5. **Check it.** Using that `list_layouts`, run `get_clip_frame` in the middle of the base layout and of the changes that matter most. Fix any camera that covers text, a cursor, a menu or a result, and any change that landed on the wrong words.
6. **Report** in a few lines: the base layout, each change with its time and why, and anything you left alone on purpose.

## What the viewer should see

At every moment, ask what the viewer should look at:

- **The screen** when something is happening or being pointed at: a click, typing, a menu, a result appearing, a slide change, code, a chart, or a sentence about what is visible ("this", "here", "as you can see"). Never hide the screen during those moments.
- **The speaker** for a greeting, a hook, an opinion, a reaction, a joke, a takeaway or a sign-off while the screen is static or unimportant.
- **Both** for most of everything else, which is what the base layout is for.

### The base layout

The base layout is the home shot and carries most of the clip. Pick it for the clip as a whole:

- Screen-led demos and tutorials: `camera-bubble` at size M, in the corner that covers the least.
- Talks, pitches and recaps where the speaker matters as much as the slides: `side-by-side` (`overlap` or `regular`) or `tv-presenter`.
- If the clip already has a deliberate base layout (a camera style, a pop-out, a cut-out presenter, a custom layout), keep it and only add changes.
- Otherwise, if the user has a Favorite layout that suits the clip's base, use it rather than a default: favorites are the user's own look.

### Layout changes

A layout change needs a reason a viewer would feel. Most of the clip stays on the base layout, with gaps between changes. Back-to-back changes are for a deliberate mini-sequence, such as a fullscreen camera shot followed by a punch-in on the key phrase. A few well-placed changes per minute at most is plenty, and a static or very short clip may need none. Too many changes is the most common complaint about auto layouts, so when in doubt, leave the base layout. A Short is the exception: in a vertical video of a minute or less, follow the pace in the `tella-short` skill instead.

Useful changes, in the MCP's vocabulary (the `add_layout` schema lists what each `layoutSceneType` accepts):

- **Screen focus** (`screen-only`, or the bubble shrunk to size S): dense UI, code, settings or a result that needs full attention. Often 2–8 s, and longer while the detail is being worked through.
- **Camera cutaway** (`camera-only` with `style: fullscreen`): a strong human moment while the screen is quiet. Usually 2–5 s.
- **Punch-in** (`camera-only` with `punchIn: true`): the strongest words of a cutaway or an opening hook. At least 1.5 s, ideally 2–4 s.
- **Bubble size accent** (the same `camera-bubble` at size L, then back to the base): commentary or a reaction while the screen still matters.
- **Split or presenter** (`side-by-side`, `tv-presenter`): a stretch where both the speaker and a slide or page matter. Avoid them for small text or code.

Where a usable favorite does the same job as one of these (a screen-led favorite for screen focus, a camera-led one for a cutaway), prefer the favorite.

The opening: if the first sentence greets or sets up without needing the screen, a short camera opening works well. If it already refers to something on screen, the screen must be visible from the first frame.

A clip with only a screen or only a camera recording has little to switch between: keep to a handful of punch-ins or focus moments, or leave the base layout alone.

### Placement and gaze

Put the camera on the side the speaker faces away from, so they look toward the screen. If they look to the viewer's left, put the camera on the right (`position: right` for splits and presenters, a right-hand corner for a bubble), and the other way round. If they look straight ahead, choose the side that covers the least important content. Once chosen, keep the side stable: change the size or layout before moving the camera, and move it only when it would cover something the viewer needs.

### Transitions

`transitionStyle` sets how a layout enters: `hardCut` or `spring` (animated).

- Use `hardCut` between fundamentally different full-frame shots (screen-only to camera-only and back), and into a short camera cutaway.
- Use `spring` for bubble size changes, split and presenter changes, and a gradual push into a punch-in.
- A punch-in can `hardCut` for a quick, decisive beat, or `spring` when the same thought builds.

A change exits with the `transitionStyle` of the layout that follows it, often a base section (`followsBase: true`). After a full-frame camera change, check that layout in `list_layouts` and set it to `hardCut` with `update_layout` when the return to the screen would otherwise animate.

## If something goes wrong

If `apply_video_edits` fails, nothing was changed: fix the operation it names and send the batch again. If a call's outcome is unclear, run `list_layouts` before retrying, and never add the same layouts twice. To start over, remove the clip's layout changes and apply the plan again.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-camera-moves
description: Move the camera in a Tella video with purpose through the Tella MCP, using zooms into screen recordings (fixed or following the cursor), punch-ins on the speaker, slow zooms on stills, and camera moves inside Tella Motion shots (push in, pull back to reveal, pan between parts, focus pulls), each with a reason and a hold. Use when asked for zooms, punch-ins, camera movement, a Ken Burns move, or to make a static shot or a screen recording more dynamic.
---

# Camera moves

Every move points the viewer at something, then the camera holds while it is read.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

## Tools

- Screen footage: `add_zoom`, `manualZoom` on a `focusPoint` (percent of the footage) or `trackingZoom` to follow the cursor, `scale` up to 3.5, `smooth` or `hard_cut` in and out; the pace for the video is `zoomAnimationStyle` on `update_video`. Several at once: `apply_video_edits`.
- The speaker: a punch-in is a layout (`fullscreen` with `style: "stretch"` on a camera clip, `camera-only` with `punchIn: true` on a screen-and-camera clip), never a zoom.
- A still image or page as b-roll: one slow `manualZoom` across its whole shot.
- Inside a Tella Motion shot: group what the camera films and key the group's `x`, `y` and `scale`; key `blur` for focus. For depth, see `tella-ui-parallax`.

## Moves

- **Zoom to read**: into the field, button or number the speaker names, on the word, 1.5 to 2.5×; hold until the action is done, then out.
- **Follow**: `trackingZoom` only while the cursor travels across the screen.
- **Punch-in**: on a stressed line, 2 to 6 s, then back; about one every 20 s at most.
- **Push in**: a slow move toward the subject across a whole shot, to add weight.
- **Pull back to reveal**: from a detail out to what it belongs to.
- **Pan between parts** of a wide image or page, holding at least 1 s at each.
- **Focus pull**: blur one layer as the next sharpens.

## Rules

One move at a time, 0.4 to 0.8 s (a slow push is the exception), each ending in a hold of at least 1 s. Don't zoom past where text turns soft.

## Check

`get_filmstrip` at the start, middle and end of each move: the target centred and readable, nothing cut at the edges, no jump on the way out.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-carousels
description: Show several images, screens or clips as a carousel in Tella Motion, through the Tella MCP, with cards riding one path (a ring, an arc, a row or a stack) driven by one curve, depth from scale, blur and dimming, and the card that matters landing front and centre on its word. Use when asked for a carousel, a gallery, a showcase of several screens, products, photos or testimonials, or b-roll that shows many things at once. Builds on tella-motion-design. Needs the Tella Motion tools, which are in beta and not available in every workspace.
---

# Carousels in Tella Motion

A carousel says "there are many of these", then lands on the one that matters. Follow `tella-motion-design`; load it first.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

## Build

- One card per item, from the user's real media (`addMedia`), all the same size, corner radius and shadow. Four to nine cards.
- One driver: key the carousel's position in one curve (`setCurve` `phase`), and bind each card's `x`, `y`, `scale`, `opacity` and `blur` to expressions of `phase` plus that card's offset (`bindProperty` with `sin`, `cos`, `add`, `multiply`). Paths:
  - ring from the front: x from sin, scale and brightness from cos;
  - tilted ring: also y from cos (flattened) and a small `rotateY` following sin;
  - arc or row: x along the path, scale peaking at the centre;
  - stack: the front card throws off and the others step forward one place.
- Depth: the front card at full size, sharp and fully lit; further cards smaller (down to about 0.6), a few px of blur, dimmed.
- Layer order can't change during playback. For a full ring, give each card a back copy and a front copy in two groups (back group first) and switch them with `opacity` bound to `step` of its cos. For arcs and rows, order cards by resting depth so they never cross.

## Motion

- Ease in and out between rests: 0.6 to 1 s of travel, then at least 1 s of rest.
- The hero card lands front and centre on the word that names it and holds at least 2 s, or the camera pushes into it to start the next shot.
- Never leave a carousel spinning as decoration.

## Check

`get_motion_frame` at a rest, mid-move and the landing: the hero sharp and uncovered, no pop when a card switches copies, every card the user's own media.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-changelog-video
description: Turn release notes, a changelog or a list of shipped changes into a short product update video in Tella through the Tella MCP, picking the changes users will notice, one beat per change shown in the real product, in the brand's look, and quick to repeat every release. Use when asked for a changelog video, a release or update video, a "what's new" video, or a video from release notes or merged pull requests.
---

# Changelog video

One beat per change a user would notice, the same shape every release.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

## Plan

1. Read the notes the user gives (pasted text, a file, a link). Keep what users will notice, fold small fixes into one line, drop internal work: three to six beats. Say what you left out.
2. One line per beat, in the notes' words: what you can now do, and where. Never claim more than the notes say.
3. A visual per beat: the user's recording of it, a screenshot as a parallax shot (`tella-ui-parallax`), or redrawn UI doing it (`tella-ui-redraw`). Ask for the screens you don't have.
4. Show the plan as `tella-plan-video` does and wait for a go.

## Build

- Open on the release name or date and the biggest change, not on a logo.
- Each beat: a short title (`tella-kinetic-type`), then its visual, 4 to 8 s, with one transition kind throughout (`tella-transitions`).
- End on where to try it, exactly as given. Music under it (`set_background_music`), quiet under a voice.

## Next time

Make the first one the template. Then `duplicate_video` it and swap each beat's text, screen and date; offer to save the title style (`save_text_preset`) and layouts (`save_layout`).

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-data-callouts
description: Show the numbers a speaker says in a Tella video as animated graphics, through the Tella MCP, as big stats, before-and-after comparisons, bars, percentages and count-ups, each timed to the spoken number and checked against the transcript. Use when asked to visualize stats, metrics, results, growth, pricing or any numbers in a video, or for data callouts or animated charts. Builds on tella-motion-design. A single stat can be a text overlay; charts use the Tella Motion tools, which are in beta and not available in every workspace.
---

# Data callouts for a Tella video

When the speaker says a number that matters, make it visible: the number large, what it measures beside it, and, for a comparison, its shape. Follow `tella-motion-design` for the look, timing, placement and checks; load it first if you haven't.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

- **Accuracy first.** Show each number exactly as said, with its unit and sign ("3 days → 4 hours", not "3 → 4"). Never invent data: one number said means one number shown, not a chart with made-up neighbours. Draw bars and blocks to scale from zero.
- **On the number.** A figure appears when it is spoken, never earlier. Figures said together ("200 shops in 12 cities") build up in one callout as each is said, rather than swapping cards.
- **Number first.** The number is the largest thing in the callout, in the accent colour, with a short label of what it measures (a few words) smaller beneath it.
- **Pick the treatment for the figure**: a big stat with its label for a single number, two bars or blocks for a before and after, a ring or bar for a percentage, a count-up only for a total or growth that deserves it.

Check a frame of every callout at its final value against the transcript, and report each with the line it comes from.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-explainer-graphics
description: Turn an explanation in a Tella video into a diagram that builds itself as the speaker talks, through the Tella MCP, for processes, flows, architectures, comparisons, hierarchies, timelines and cycles, as Tella Motion b-roll or an overlay, with each part appearing as it is named. Use when asked for explainer graphics, an animated diagram, a visual for a concept, or b-roll that explains rather than decorates. Builds on tella-motion-design. Needs the Tella Motion tools, which are in beta and not available in every workspace.
---

# Explainer graphics for a Tella video

When the speaker explains something that has a shape and nothing on screen shows it, draw it: one diagram that builds up part by part as each part is named. Follow `tella-motion-design` for the look, timing, placement and checks; load it first if you haven't.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

- Pick the diagram that fits the idea (a row of steps, boxes and arrows, two columns, a tree, a timeline, a ring) and keep it simple: shapes with short labels on them, no paragraphs or legends.
- Lay out the finished diagram first, then reveal it in the order of the speech. Parts appear where they stay; nothing reshuffles. Arrows draw in the direction things move.
- Cover the explanation from its first word to its last: the diagram has something on screen as it starts, the last part gets time to be read, and the finished picture holds briefly before it leaves.
- Show it as b-roll (`add_layout` with `media: {type: "motion", documentId}`) for the explanation's range, keeping the speaker visible when their delivery matters, or as an overlay beside a speaker who doesn't fill the frame.

Check frames as parts arrive and of the finished diagram, then report the diagram, its range and its parts.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-kinetic-type
description: Add kinetic typography to a Tella video through the Tella MCP, setting the lines that matter set as animated text that lands on the spoken word. Use when asked for kinetic type, animated text, text callouts, keyword pop-ups, or to make a talking video more dynamic with type. Builds on tella-motion-design. Most styles use text overlays; the full-frame hook and richer type use the Tella Motion tools, which are in beta and not available in every workspace.
---

# Kinetic type for a Tella video

Find the lines worth seeing as well as hearing, and set them as type that arrives on the word and leaves when the thought ends. Follow `tella-motion-design` for the look, timing, placement and checks; load it first if you haven't.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

## What to type out

The lines a viewer should remember, each cut to its key phrase: the hook or opening question, the speaker's name and role when they introduce themselves, a claim the speaker stresses, a list as it is counted off, a number that matters, the takeaway, and the call to action with its link exactly as said. Choose how many from the video and the request; don't pad a sparse video, and don't skip a strong moment to keep the count down. Word-by-word captions are the subtitles feature, not this skill.

## Styles

Pick one or two that suit the video:

- **Emphasis words** (the usual default): a short phrase in the empty side of the frame, revealed word by word in step with the speaker (`textIntro` with `text.unit: "words"` and a `delayMs` that follows the transcript).
- **List build**: each item appears as it is said, in a column in one spot, and the list leaves together when the last item is done.
- **Titles behind the presenter**: big words behind a speaker who fills the frame (`depth: "behind_presenter"`); check that the key letters aren't all hidden.
- **Hook**: a short full-frame type sequence over the opening line, as Tella Motion b-roll, so the speaker's voice carries it.

Use Tella Motion only for what overlays can't do, such as mixed colours in one line or type that grows out of a shape.

## Moves

Text overlays animate the whole overlay (`intro`, `outro`) and its letters, words or lines (`textIntro`, `textOutro` with `text.unit`) from the presets `fade`, `slide_*`, `mask_up`, `mask_down`, `grow`, `shrink`, `blur` and `blur_slide_up`, adjusted by move, scale, blur and `clip`. Tella Motion titles add `setTextAnimation` (`typewriter`, `rise`, `drop`, `pop`, `spread`, `spin` and others, by character, word or line, in any order), keyed font weight and mattes. One or two of these per video:

- **Word roll**: one word in a held line changes through options: an overlay per option in the same box, each entering and leaving `mask_up` with `clip`, the last one held.
- **Strike and replace**: a line draws across the old word (a shape overlay wiping in, or a Tella Motion path with `trimPath`), then the new word takes its place.
- **Weight shift**: the stressed word, as its own Tella Motion title, goes from regular to black as it is said (key `fontWeight`; needs a variable font).
- **Typed line**: `typewriter` by character at speaking pace, for a prompt, a search or a link.
- **One shimmer**: a soft light band crosses a title once (a moving gradient shape matted to the title with `setMatte`). Never looping.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-launch-video
description: Make a launch, promo or feature announcement video in Tella through the Tella MCP. Asks what is launching and what material exists, picks a launch shape (founder to camera with product graphics, product walkthrough, music-only trailer, vertical feature drop), plans it, then cuts, lays out, shows the product, adds proof, music and an end card, and checks every frame. Use when asked for a launch video, product video, promo, trailer, teaser, feature announcement or a video for a landing page or launch post.
---

# Make a launch video in Tella

A launch video makes one promise and proves it in the real product.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

## Scope

Ask, then show a plan and wait for a go before the first write. After the go, build it all and report. Edit a copy (`duplicate_video`) when the recording is used elsewhere.

## 1. Ask and pick the shape

Ask in one message, guesses filled in: what is launching and for whom, the one task to show done in the product, the material (recording, screen recording, screenshots, site, logo, brand colours), the voice, where it plays, and the call to action exactly as it should read.

| Shape | When |
| --- | --- |
| Founder to camera with product graphics | The user talks to camera; trust in a person matters |
| Product walkthrough | A screen recording of the real flow exists |
| Music-only trailer | No voice; a feed, a hero section or a teaser |
| Vertical feature drop | One feature for a social feed, 9:16, 15 to 40 s |

A vertical feature drop follows this skill's plan, build and end card at 1080×1920. From an existing talking recording, borrow `tella-short` for the 9:16 copy, captions, pace and phone checks; this plan replaces its segment pick, and the end card replaces its end-on-speaker rule. With no speaker (music and type, or screenshots), skip `tella-short`'s speaker rules.

## 2. Plan

Plan with `tella-plan-video` on this shape: hook (~10%, the product working or the need, never a logo first), problem (~15%, shown), reveal (~10%), proof (~40%, three to six actions in the product), payoff (~15%, the result at full size), ask (~10%). A long, loose take gets a short script to re-record rather than a cut. List each product shot as a zoom into the recording, a parallax shot of a screenshot (`tella-ui-parallax`) or redrawn UI that acts (`tella-ui-redraw`).

## 3. Build

1. Cut the speech (`tella-auto-cut`) and check every seam; launches have no room for a stumble.
2. Lay it out (`tella-auto-layouts`). On a founder launch the speaker stays visible most of the time; product shots sit beside them or in a split, full screen only for the payoff.
3. Product shots as planned, the first one built and checked, the rest made from it.
4. Proof, only what the user gives: a quote word for word with the person's name and photo; a logo wall from the brands' own files; a real number (`tella-data-callouts`); a before and after (the old way piling up, then the calm new way).
5. Type for the hook and the claim (`tella-kinetic-type`), transitions (`tella-transitions`), and the brand's background (`list_backgrounds`).
6. Music under the voice (`set_background_music`); sound effects only on visible actions.
7. End card (`tella-title-cards`): the logo from the brand's file, the call to action exactly as given, held at least 2 s.

Never invent a feature, screen, customer, logo, quote or number; put a labelled placeholder ("Screen: Billing → Invoices") and ask for the real one.

## 4. Check and report

Run the checks in `tella-motion-design`, plus: the hook reads muted in the first 3 s, each product shot matches its source, the face is never covered. Report the link, length, shape, one line per beat, placeholders still open, and what to listen to.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-motion-design
description: The shared rules for motion graphics in a Tella video, used through the Tella MCP, covering one look per video, graphics timed to the spoken word, placement clear of the speaker, and checking the result. Load it whenever you add text, titles or animated graphics to a video, including a general request to add motion graphics, and before any other graphics skill. Text overlays work everywhere; richer graphics use the Tella Motion tools, which are in beta and not available in every workspace.
---

# Motion design for Tella videos

Graphics in a Tella video serve someone talking or showing their screen. A good graphic lands on the word it illustrates, says less than the speaker, stays long enough to read, and gets out of the way. Restraint looks designed; effects look like a template.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

## Tools

Use text overlays first: they work without Tella Motion and stay editable like any text. Use highlights to point at UI in a screen recording. Use a Tella Motion document (an overlay, or b-roll through `add_layout` with Tella Motion `media`) only when several elements must move together, such as a diagram or a chart. Add a Tella Motion clip only when the user asks, since it changes the video's length. If the Tella Motion tools are missing, say so and do what the rest can.

## A request for the whole video

For a general request ("add some motion graphics"), go through the video stretch by stretch and give each part what it needs, loading the matching skill: the hook and key lines as type, numbers as callouts, a screen demo's steps as screen callouts, an explanation with a shape as a diagram, several things shown at once as a carousel, product screens as redrawn or parallax UI, and the call to action. Leave stretches that need nothing alone.

## One look

Decide the look before building and keep to it: one typeface (reuse the video's text presets or existing overlays when it has them), a few colours with one accent, and a clear hierarchy: the key word or number large and in the accent, supporting text smaller and plainer, the same size for the same role every time. One calm easing. No bouncy, elastic or spring easing. Every graphic has an exit. Check contrast against what is really behind the text, and don't add shadows or outlines it doesn't need.

## Timing

Place each graphic from the transcript's word timings, not its sentences. Nothing appears before it is said: a graphic starts entering just before its first word, and a word-by-word reveal follows the speaker's pace. Keep each graphic up until its thought ends, and long enough to read (at least about 2 s). Things said in one breath go in one graphic rather than a quick run of swaps. One graphic leaves before the next arrives in the same place.

## Between shots

Motion carries across a cut: the next shot enters on the same axis and in the same direction the last one left, at the same speed, and the cut lands mid-move rather than after both have stopped. Keep one main direction of travel for the video, and use another only when it means something (up for a reveal).

## Words

A graphic is a headline, not a caption: at most seven words on screen, usually one to four. Never put a whole spoken sentence on screen. Use the speaker's words, shortened only when the short form keeps the meaning, including any condition ("retried within an hour", not "auto retry"). Never add a claim, number, name or link the video doesn't give; check against the transcript and the video's title.

## Placement

Put graphics in the empty part of the frame, clear of the whole person (head, shoulders and body, not just the face), the cursor, the camera bubble and whatever the speaker is showing. Look at a frame of each kind of shot to see where those are. Keep everything well inside the frame, and put the same kind of graphic in the same place each time.

## Build, check, report

1. Read the video: `get_video`, `get_timeline`, `get_transcript` with word timings, frames of each shot, and the existing overlays and presets.
2. Show a short plan, one row per graphic with its time, words and placement, then build it without asking again; the user can undo or ask for changes.
3. Build the first graphic of each kind, check it, then make the others from it (the same fields or a saved text preset; `duplicate_motion_document` for Tella Motion) instead of rebuilding each one.
4. Check every graphic with `get_clip_frame`, then read the overlays back against the transcript: on its words, readable, not overlapping, nothing covered, every name and number right. Then measure:
   - each line stays at least 0.3 s a word plus 0.5 s, and its text is at least about 28 px tall at 1080p;
   - `get_filmstrip` at -0.2, -0.1, 0, +0.1 and +0.2 s around every cut and every graphic's entry and exit: no blank, white or black frame, nothing half-built or jumping. Overlay and b-roll times are on their clip's timeline; add the clip's start for video-wide tools.

   Fix everything that is wrong, unreadable or broken before reporting; mention smaller polish.
5. Report the look and each graphic with its time.

Keep text live: never turn it into an image to work around a rendering problem; report the problem as a Tella bug instead. For text behind the speaker use `depth: "behind_presenter"`. If a write's outcome is unclear, read the state back before retrying, and never add the same graphic twice.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-plan-video
description: Plan a Tella video before anything is recorded or edited, through the Tella MCP. Asks what the video is for, then writes the one-line point, a story outline, a word-for-word script sized to the length, and a shot-by-shot storyboard, and waits for a go. Use when someone wants help with what to say or show, a script, a storyboard, an outline or a shot list, wants to plan a launch, demo, tutorial or pitch, or has a long rambling take and wants a tight version to record again.
---

# Plan a Tella video

Agree on what the video says and shows while changing it costs a sentence. Then record to the plan and edit to the plan.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first. Planning from scratch works without it.

## Scope

Planning writes nothing to any video. Show the plan, then wait for a go or notes; notes change only what they name. If the user has a script, outline or reference, plan from theirs and keep their words. If they ask for one part (just a script), give that part.

## 1. Ask once

One message (a form when your client has one), your best guess filled in for each, only what the material doesn't answer:

- what it's for (launch, demo, tutorial, pitch, update, Short) and who watches where (this sets length, aspect ratio and whether it must work muted);
- the one thing the viewer should remember or do;
- what exists: a recording, the product to screen record, screenshots, a site, logo and brand colours;
- who is on camera: the user, a voiceover, or no voice;
- the length; otherwise propose one (30–60 s launch or social, 1–3 min demo or pitch).

## 2. The plan

1. **The point**, one line in the viewer's words ("You can now …").
2. **The shape**, one line of beats: launch: hook, problem, reveal, proof, payoff, ask; demo or tutorial: result first, each step, result again, next step; pitch: their problem, its cost, what you do, proof, the ask.
3. **The script**, word for word, short sentences in the user's own words, about 150 words a minute (45 s is about 110 words), with its word count. Open on the hook, never "Hi, I'm" or "In this video".
4. **The storyboard**, one row per line: the words it starts on, the layout, what's on screen (name the real screen to record), and any graphic. Mark anything generated: it costs AI Credits.
5. **To record**: the takes in order, one per beat, and what to have open.

Every claim, number, name and logo comes from the user. Leave a marked gap ("[how many customers?]") rather than invent one.

## A take that already exists

Don't search five rambling minutes for a 45-second video. Either the transcript already says it (plan an edit: first and last words of each stretch kept), or write a tight script from what they said and plan a new take. Say which and why.

## After the go

Give the script as plain text for the recorder's Notes (the teleprompter). Then build with the other skills (`tella-auto-cut`, `tella-auto-layouts`, the graphics skills, `tella-launch-video`, `tella-short`), and say in the report where the edit drifted from the plan.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-remove-mistakes
description: Find and remove recording mistakes (false starts, retakes, repeated phrases, abandoned sentences, technical interruptions) from a Tella video's transcript through the Tella MCP. Use when asked to remove mistakes, clean up retakes, or tighten a recording by cutting flubbed takes.
---

# Remove mistakes from a Tella video

Read the transcript, find the mistakes using the rules in [references/mistake-rules.md](references/mistake-rules.md), show them to the user, and cut the approved ones with `cut_clip_by_transcript`.

This skill needs the Tella MCP. If tools such as `get_transcript` are missing, follow the connection steps in the `tella` skill first.

## Scope

Mistakes are not filler words or silences. For standalone "um"/"uh", use `remove_fillers`; for pauses, use `get_silences` / `remove_silences`. Only do those if the user asked for them too, and on each clip send them only after its `cut_clip_by_transcript` call has returned: calls on the same clip that run together each return the clip as they saw it, so one result can be missing the other's cuts.

Finding mistakes is read-only. Do not cut anything until the user has approved the list, unless they explicitly asked you to remove the mistakes without reviewing.

Once the user has answered, cut only what they approved. A mistake you spot after that (while re-reading the seams, or in a later turn about something else) is a new finding, even when it looks like the rest of an approved one: list it and ask, don't cut it.

## Workflow

1. **Find the clips.** `get_timeline` lists the video's clips. Work clip by clip: transcripts, word indices and cuts are all per clip. Before cutting, call `get_clip` on each one and keep its `cuts`, so you can restore it.
2. **Read the transcript.** Read every word of the clip with `get_transcript` `view: "text"`: one sentence per line with its start time, each word prefixed with its stable `index` (`12:word`), on the clip's playback timeline (existing cuts already removed). Several rules compare neighbouring sentences.
   - Read it in windows of about 5 minutes with `startTimeMs`/`endTimeMs`, one window per step, and start each window after the first about 30 seconds before the previous one ended, so retakes that span a window edge are still visible. Finish a window (step 3 below: write down its mistakes as word ranges) before you request the next one. A mistake found twice in the overlap, with similar bounds, is one mistake.
   - Don't look for mistakes in the sentences view, which hides the words inside each sentence: retakes and repeated sentences get missed that way. Read the words view (`get_transcript` without `view`) only for a stretch where you need exact word times or want to check a doubtful finding.
3. **Spot the mistakes.** Apply [references/mistake-rules.md](references/mistake-rules.md). Each finding is an inclusive word-index range, a short reason (for example "False start" or "Repeated phrase"), and the words it removes. When unsure, leave it in: over-trimming is worse than under-trimming.
4. **Show the list before cutting.** For each finding give the time, the reason, the words that would be cut, and a few words of context on each side so the user can see what the sentence becomes. Let the user drop or adjust items. Report clips where nothing was found too.
5. **Cut.** Call `cut_clip_by_transcript` once per clip with every approved `{fromWordIndex, toWordIndex}` range. Word indices do not shift when cuts change, so the ranges stay valid. Never pad ranges with extra words "for safety", and never split a word.
6. **Check the seams.** Re-read the transcript around each cut. Look at the gap between the last word before the cut and the first word after it. A word that ends right at the cut, especially one ending in a consonant, can sound clipped, and mistake cuts are where that happens, so listen to the seams once: download the MP4 that `get_clip_preview` returns (it has the clip's audio), cut each seam's range to audio with ffmpeg (`ffmpeg -ss 2 -t 6 -i preview.mp4 -vn -ac 1 -ar 22050 -b:a 48k seam.mp3`), join them into one file and listen to it with your audio tool (`describe_audio` in the Tella editor). If the listen and the transcript disagree, `get_audio_levels` for those few seconds settles whether the word is whole. If a seam sounds wrong, move the cut by a whole word rather than adjusting milliseconds. Confirm the sentence now reads as intended.
7. **Report** what was cut per clip, what you left in on purpose, and what you verified (transcript re-read, seams listened to). If you didn't listen, say so in a few words.

A cut call that returned the clip succeeded; don't send it again, even when a later result seems to lack its cuts. If a cut call fails or its outcome is unclear, re-read the transcript before retrying: words that were cut are absent from it. When `cut_clip_by_transcript` reports word indices not found, those words are already cut: drop those ranges and send the rest once. Never blindly repeat a cut.

To undo, call `update_clip` with the `cuts` you saved before cutting, then re-apply the cuts you want to keep. Prefer that to guessing at a partial undo. `cuts` replaces the clip's whole cut list, and the person may be editing the video by hand while you work: keep any cut in the current `get_clip` that neither you made nor was in the saved list, and send `cuts: []` only when that is the result: the saved list was empty and the current clip has no cuts to keep, or they asked to remove every cut.

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: tella-screen-callouts
description: Point at things in a Tella screen recording with callouts, through the Tella MCP, using a highlight that dims everything but the target, paired with a short label naming the step, numbered through a walkthrough and timed to the click or the words that mention it. Use when asked to annotate a demo or tutorial, add callouts, arrows, labels or highlights to a screen recording, or make a walkthrough easier to follow. Builds on tella-motion-design. Highlights and text overlays work everywhere; arrows use the Tella Motion tools, which are in beta and not available in every workspace.
---

# Screen callouts for a Tella video

Help the viewer find what the speaker is operating or talking about. Follow `tella-motion-design` for the look, timing, placement and checks; load it first if you haven't.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

- **Find the steps.** `get_mouse_events` (clicks) and `get_key_events` show where the screen is operated; the transcript shows what the speaker names. Cover every step they walk through, the last one included, and a result they point at. Skip clicks nobody mentions.
- **A highlight with a label.** Each callout is a highlight (`add_highlight`) that dims everything but the target, plus a short text label naming the step the way the UI does ("Export", "Share → Invite"), numbered through a walkthrough. One callout per action the speaker describes: a menu path they say in one breath ("Share, then Invite") is one callout that follows the clicks, not a quick run of separate ones. Keep the dimming moderate (`intensity` about 0.5) so the screen stays readable. The label sits beside the target in empty space, never over another control, the cursor or the camera bubble.
- **On target.** Highlight positions are percentages of the screen recording, not the canvas: convert click pixels with the recording size from `get_mouse_events`, and pad the box generously so the whole control sits well inside it. Labels are placed on the canvas, from a frame at that time.
- **Steady.** Start each callout just before its click or word and hold it until the action is done. When one callout follows another closely, end the first where the next starts, so the dimming doesn't flicker.

Don't change cuts, layouts or zooms. Check a frame in the middle of each callout and report each with its time and target.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-short
description: "Turn a Tella video into a vertical Short, Reel or TikTok through the Tella MCP: pick its strongest 15 to 60 seconds, make a trimmed 9:16 copy, tighten it, add captions, and lay it out at Shorts pace with a hook, B-roll that moves and the speaker on screen. Shows a scene-by-scene plan first, then builds it and checks every cut. Use when asked to make a Short, Reel, TikTok, clip, teaser or vertical version of a video."
---

# Make a Short from a Tella video

A Short is watched on a phone, often muted, by someone one swipe away from leaving. It needs a hook in the first seconds, a new shot every second or two, captions that carry the words, and an ending that pays off the hook. Pick the part of the video that can do that, copy it into a new 9:16 video, and edit the copy at that pace. Never edit the original.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

## Scope

Show a plan and wait for a go before the first write: the choice of segment is the user's call, and generated B-roll costs AI Credits. After the go, build the whole Short without asking again; the user can ask for changes.

If the user gives a time range, a chapter, a length, a platform or a style, those win over everything below. Without a length, aim for 30 to 45 seconds; never go past 60 unless the user asks.

## Workflow

1. **Read the video.** `get_video`, `get_timeline`, and `get_transcript` for each clip (in windows for long clips). `get_filmstrip` over the whole video shows what is on screen and where screen recordings, demos and results are.
2. **Pick the segment.** Find one self-contained idea that opens on a line that works as a hook, builds, and ends on a payoff or takeaway. A long tutorial usually holds several; pick the strongest and mention one or two runners-up. The segment can be one stretch, or a few stretches of the same thought when the middle wanders. Start and end on whole sentences.
3. **Plan the Short** with the rules below, and show it in chat:
   - the segment: its time range, first and last words, and the expected length after tightening;
   - the hook line and the question it raises;
   - one line per shot: the words it starts on, the layout, what is on screen, and the words spoken;
   - the B-roll sources, with links, and anything you propose to generate.

   Write each shot against its words, not its times: the times move once the copy is tightened.
4. **Make the copy.** `duplicate_video` with `startTime` and `endTime` (seconds on the video timeline, or `chapterIndex` for a chapter) and a name such as "<title> (Short)". For a segment made of several stretches, duplicate the span that covers them and cut the parts in between with `cut_clip_by_transcript`. Do every later step on the copy.
5. **Tighten it.** Run the `tella-auto-cut` skill on the copy with the `fast` silence mode, so mistakes, fillers and pauses go and the seams get checked. Then cut whatever the plan drops with `cut_clip_by_transcript`. Re-read the transcript after the last cut: every later time comes from it.
6. **Make it vertical.** `update_video` with `dimensions: {width: 1080, height: 1920}`. This remaps every layout, so run `list_layouts` and `get_filmstrip` on each clip before laying it out.
7. **Captions.** Turn them on with `update_video` (`captionsEnabled: true`, `subtitlesEnabled: true`, `captionGrouping: "chunked"`, `captionLinesPerBlock` 1 or 2). If the user has a saved subtitle preset in `list_subtitle_presets`, apply it with `apply_subtitle_preset`. Place them with `captionPosition` (see Captions below). Fix misspelled names and terms in the transcript with `update_transcript_words`, since captions show its text.
8. **Lay it out** shot by shot from the plan, using the rules below and the layout mechanics of the `tella-auto-layouts` skill (which tools, keeping the camera style, transitions). Add the B-roll with `add_layout` and `media`.
9. **Add text** where the plan calls for it, following `tella-motion-design`: the hook as type with `tella-kinetic-type`, a number the speaker says with `tella-data-callouts`. Keep it sparse: captions already carry the words.
10. **Check it** (see Check below) and fix what fails.
11. **Report** a link to the copy, its length, the segment it came from, one line per shot, and what the user should listen to, since you can only read the audio.

## Shorts rules

### The hook

- The first words are the hook: the most surprising claim, the result, or the question the Short answers. Move a stronger line to the front by starting the segment there; don't open on a greeting, a name or "so, today".
- The first 3 seconds must make sense with the sound off: the speaker's face, the strongest visual, or the hook as large type, plus captions.
- The hook raises one question, and the Short answers it before it ends. Cut a segment that never pays off.
- End on the speaker with the takeaway. Where it fits, bring back the opening visual so the Short comes full circle. Don't end on "thanks for watching" or a long outro.

### Pace

- The first shot change comes within about a second, on the first strong word.
- Most shots last 1 to 2 seconds. Hold longer only while a demo plays out or a key line lands, and never hold one framing of the speaker past about 4 seconds: change to a punch-in, a B-roll shot or a split.
- When the speaker names several things in a row, give each its own shot, card row or list item, on its spoken word.
- Use each B-roll clip once.

The "few changes per minute" guidance in `tella-auto-layouts` is for long videos. It does not apply to a Short.

### The speaker and the visuals

- Keep the speaker on screen for at least half the Short: people stay for a face. End each full-screen B-roll shot within about 3.5 seconds.
- Shots, in the order to reach for them: the speaker full frame; a punch-in for emphasis (`fullscreen` with `style: stretch` on a camera clip, `camera-only` with `punchIn: true` on a screen-and-camera clip); a split with the visual on top and the speaker below; B-roll full frame while the speaker keeps talking. The `add_layout` schema lists which kinds each clip's `layoutSceneType` accepts.
- A visual shows what the words don't: the product doing the thing, the result, the proof. Find it in this order: the recording itself (`media: {type: "recording", startTimeMs}` plays the clip's own screen recording from that moment); the user's library (`list_library`); the product's official pages and demos (`import_from_url`, with `scroll: true` for a page); and only then, if the user approved it, `generate_video`. Only use media the user has the right to use.
- Everything off the speaker moves. Never leave a still image or a static page as B-roll: record a page scrolling, use a video, or give an image a slow `add_zoom` (`manualZoom`) across its shot.
- Text on screen must be readable on a phone at a glance. When UI is too small, zoom into one whole card or field rather than cropping text at the edges.
- Never put a graphic, card or B-roll bubble over the speaker's face. Never show a video that has its own captions under this Short's captions.
- Never invent a number, result or quote. Every number on screen is one the speaker says or the source shows. Show a logo only from the brand's official file; without one, write the name.

### Captions

On a phone, the bottom fifth of the frame sits under the app's buttons, the account name and the description, and the top tenth under the status bar. Keep captions between them: above the bottom 20% of the frame, clear of the speaker's mouth and chin, and clear of text in a split's top panel. Short blocks of a few words read best. Look at a frame of each kind of shot to check.

## Check

Look at the copy as the viewer will, then answer each of these yes or no, and fix any no:

1. **The opening.** `get_filmstrip` with `timesMs` every 250 ms over the first 3 seconds, then `get_video_preview` of them. Does the hook land, and does it read with the sound off?
2. **Every shot change.** `get_filmstrip` with the frames just before, at and just after each layout change. Does each land on its word, with no blank, frozen, stretched or wrongly framed frame?
3. **The whole Short.** `get_filmstrip` across the whole copy. Is the speaker on screen for at least half of it, with no full-screen B-roll over about 3.5 seconds and no speaker shot held past about 4?
4. Do the captions stay clear of the mouth, the chin, the app's bottom area and the text in a split's top panel?
5. Is all text and UI on screen readable at phone size, with nothing cut off at a frame edge?
6. Does every off-camera shot move?
7. Is every number on screen one the speaker said or the source shows, and every logo from an official file?
8. Is the face clear of every graphic, and is there no captioned video under the captions?
9. Does the Short answer the question its hook raises, and end on the speaker?
10. Was every generated asset one the user approved?

After a fix, check that range again. If a write's outcome is unclear, read the state back before retrying, and never add the same layout or overlay twice.

## Looks worth keeping

When the user gives a note about the look (a caption style, a font, a layout), offer to save it so the next Short starts from it: `save_subtitle_preset` for captions, `save_text_preset` for a text style, `save_layout` for a layout as a Favorite.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-title-cards
description: Design a matching set of title graphics for a Tella video through the Tella MCP, covering an opening title, chapter titles at each topic change, name tags (lower thirds) for people, and an end card, all from one design. Use when asked for titles, an intro or outro title, chapter cards, section headers, lower thirds, name tags or an end card. Builds on tella-motion-design. Simple titles use text overlays; designed cards use the Tella Motion tools, which are in beta and not available in every workspace.
---

# Title cards for a Tella video

Give the video one family of titles that look related but clearly ranked, so the structure reads. Follow `tella-motion-design` for the look, timing, placement and checks; load it first if you haven't.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

- **Opening title**: the video's title (`get_video`) or the speaker's own framing, on screen from the start of the video. The largest size.
- **Chapter titles**: one for every section, the last one included, entering as the new topic starts. Use the video's chapters when it has them. Mid size, numbered when the video is a sequence of steps.
- **Name tags**: a person's name and role the first time they appear, only as the video says them. The smallest size.
- **End card**: the takeaway or the next step the speaker gives, with any link exactly as said. Large, like the opening title.

Each kind has one style and one position throughout. Make only what was asked; no extra quote cards. All of them sit in the empty part of the frame, never over the speaker or the content being shown, on one grid. Design one of each kind, check it, then reuse it (a saved text preset, or a duplicated Tella Motion document) for the rest. Titles go over the existing footage; add a separate title clip only when the user asks.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-transitions
description: Choose and build transitions in a Tella video through the Tella MCP, using the editor's clip, layout, zoom and overlay transitions, and transitions built in Tella Motion that come from something on screen (zoom through an object, an object growing into the next shot, a mask wipe, a match cut, a whip, a colour flood), timed to the cut and checked for flash frames. Use when asked for transitions, smoother or more dynamic cuts, scene changes, or to fix a jump or flash at a cut. Built transitions need the Tella Motion tools, which are in beta and not available in every workspace.
---

# Transitions in a Tella video

Most cuts in a talking video should stay cuts. A transition marks a change of place, topic or kind of shot, and the good ones are caused by something on screen.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

## What Tella has

- Between clips: `transition` on `update_clip` (`smooth` or `hard_cut`), or `defaultClipTransition` on `update_video` for every clip.
- Between layouts: `transitionStyle` on a timed layout (`spring` or `hardCut`), at the pace of `layoutAnimationStyle` on `update_video` (`gentlest` to `snappiest`).
- Zooms: `introTransition` and `outroTransition`, at the pace of `zoomAnimationStyle`. Overlays and text: their `animation`.
- Tella Motion: `setTransition` between items of a sequence (`crossfade`, `left`, `right`, `up`, `down`), and anything you build with keys, masks (`setMasks`), blur and mattes.

## Which one

- Same speaker, same place: a hard cut, or a punch-in (`tella-camera-moves`).
- Screen and camera changing shape: `spring` layouts at one pace for the whole video.
- A new topic, place or b-roll world: a built transition, inside the Tella Motion shot or as a short Tella Motion b-roll (`add_layout` with `media: {type: "motion", documentId}`):
  - **zoom through**: push into an element (a button, a card, a word) until its colour fills the frame, and start the next shot from that colour;
  - **grow into**: a card grows past the frame edges and becomes the next shot;
  - **wipe or iris**: a keyed mask opens from where the action was, such as the click;
  - **match cut**: the same shape or word in the same place on both sides;
  - **whip**: a fast blurred move, the next shot arriving the same way at the same speed;
  - **colour flood**: the subject stays while the ground changes colour.
- Three to five kinds in a video at most. No crossfade between two different worlds, and no transition on every cut.

## Timing

Moves take 0.3 to 0.6 s and hand off as `tella-motion-design` says (Between shots). A transition never hides a word: put it in a pause or under the first word of the new thought.

## Check

`get_filmstrip` at -0.2, -0.1, 0, +0.1 and +0.2 s around every transition: no white, black or empty frame, no jump, nothing half-built.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-ui-interactions
description: Recipes for animating product UI behaviour in Tella Motion through the Tella MCP, covering a button press, a menu or modal growing from what was clicked, a toggle, tabs, typing, a field that rejects or accepts, loading into content, a success check, notifications arriving, a sheet sliding up, a list filling and a number counting. Use with tella-ui-redraw when redrawn UI has to act, or when asked to animate a UI state change. Needs the Tella Motion tools, which are in beta and not available in every workspace.
---

# UI interactions in Tella Motion

Each recipe is one cause and its effect, on the word that names it. Draw the UI with `tella-ui-redraw` first. One easing for the video, no bounce on UI.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first.

| Interaction | Build | Time |
| --- | --- | --- |
| Press | the button scales 1 → 0.96 → 1 and darkens; the effect starts on release | 0.15 s |
| Menu or modal | the clicked element grows into the panel (key its box, corner radius and position); its content fades in once it is mostly open | 0.3–0.4 s |
| Toggle | the knob slides and the track recolours | 0.2 s |
| Tabs | the indicator slides to the new tab and resizes; the panel swaps with a short fade | 0.25 s |
| Typing | `setTextAnimation` `typewriter` by character, about 12–15 a second, with a caret shape | |
| Reject or accept | three quick side-to-side keys (±8 px) and a red border, or a green border and a check | 0.3 s |
| Loading | grey placeholder bars, then the real rows fade in over them (`stagger`) | 0.4 s, 60 ms apart |
| Success | a circle scales 0.8 → 1 and a check draws (`trimPath`) | 0.4 s |
| Notifications | each card slides in from its edge and pushes the earlier ones down | 0.35 s, ≥0.4 s apart |
| Sheet or drawer | slides in from its edge; the screen behind dims a little | 0.35 s |
| List fills | rows enter one after another with a few px of travel (`stagger`) | 40–80 ms apart |
| Number | counts to its real value (`bindProperty` of the title text to a keyed curve, with `decimals`, `prefix`, `suffix`) | 0.6–1.2 s |

Use the product's real states, labels and colours. One thing acts at a time, and the result holds at least 1 s.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-ui-parallax
description: Turn a real product screenshot into a parallax shot in Tella Motion, through the Tella MCP, by cutting its pieces out with masks, stacking them as depth layers over the blurred, dimmed screen, and moving one camera through them so near layers travel further, with shadows, depth blur and an optional slight 3D turn. Nothing is redrawn, so it is quick and exactly the real UI. Use when asked for a parallax product shot, a 2.5D or 3D-feeling screenshot, to make a screenshot pop or pull a piece of the UI out, or for b-roll from a screenshot. To rebuild UI that animates its interaction, use tella-ui-redraw. Builds on tella-motion-design. Needs the Tella Motion tools, which are in beta and not available in every workspace.
---

# Parallax shots from a screenshot

Cut a few pieces out of the real screenshot, lift the one that matters towards the viewer, let the rest fall back into soft focus, and move one camera through the stack. Follow `tella-motion-design`; load it first.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first. If the Tella Motion tools are missing, offer a slow `add_zoom` on the screenshot instead.

## Source

A sharp, large capture (2× if possible): the user's screenshot, a recording frame (`get_clip_frame`), or the product page (`import_from_url`). A lifted piece is shown larger than captured; if the source is small, say it will look soft. Crop it in the sandbox to read each piece's box and corner radius in image pixels.

## Layers, far to near

| Layer | Holds | Depth factor |
| --- | --- | --- |
| Ground | a brand colour or soft gradient, larger than the canvas | 0.15 |
| Screen | the whole screenshot as a window, soft shadow; blurred 2–6 px and dimmed 15–30% once a piece lifts | 0.4 |
| Panel (optional) | a larger section the hero sits in | 0.7 |
| Hero | the one piece the words are about, sharp, 1.2–1.6× | 1 |
| Foreground (optional) | a cursor, badge or notification cut from the same image | 1.3 |

One hero per shot, at most three lifted pieces.

## Build

- `addMedia` the screenshot once. Each piece is a `duplicate` of the screen node with a rect mask (`setMasks`, the piece's box and `radius`, no feather), so it sits exactly on its place.
- The lift, on the word that names it (0.6–0.9 s, long ease out): the hero scales up and moves slightly toward the centre while its shadow grows softer and further, and the screen behind blurs and dims, which also hides the hole it leaves.
- The camera: key `cam.x`, `cam.y` (and `cam.zoom` for a push) with `setCurve`. Wrap each layer in its own group and bind the group's `x` and `y` to the camera times its depth factor (`bindProperty` with `multiply`); key the lift on the piece inside, so keys and bindings never sit on the same property. The drift is slow: a few percent of the frame over the shot.
- No 3D turn unless the user asks for one; then `perspective` 1500–2500 px and `rotateY` under 8° on the screen group during the move only, flat before text must be read.
- Ground and screen larger than the canvas by the camera's travel.

Place each shot as b-roll or an overlay as `tella-ui-redraw` does, and make later shots from the first (`duplicate_motion_document`).

## Check

`get_motion_frame` before the lift (pieces exactly on their places), at the lift (hero sharp at 100%, no hole or ghost), and at the ends of the move (no edge in view); then the frames around the shot in the video.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: tella-ui-redraw
description: Redraw a product's real screens natively in Tella Motion, through the Tella MCP, as live shapes, text and paths that stay sharp at any zoom and can be edited, simplified to what the shot needs and animated so the product performs its real interaction. Use when asked for animated UI, UI motion graphics, a product animation, motion plates of the product, or to rebuild a screen so it can act. For depth from a screenshot without redrawing it, use tella-ui-parallax. Builds on tella-motion-design. Needs the Tella Motion tools, which are in beta and not available in every workspace.
---

# Redraw product UI in Tella Motion

Rebuild the real interface with Tella Motion's own shapes and text, simplified to what the shot needs, and let it perform one action. Follow `tella-motion-design`; load it first.

This skill needs the Tella MCP. If tools such as `get_timeline` are missing, follow the connection steps in the `tella` skill first. If the Tella Motion tools are missing, offer zooms and callouts on the recording instead.

## Source

Every piece that claims to be the product comes from it: a frame of the user's recording (`get_clip_frame`), their screenshots, or the product's page (`import_from_url`). Read labels, values, icons, spacing, radii and colours from a full-size crop. Never invent a control, chart or customer; build a labelled placeholder and ask.

## Rebuild

- **The hero piece** in full, with its real text: the panel, card, field or chart the action happens in, at 1.5 to 2× its size in the product, so text is at least about 26 px tall at 1080p.
- **The context** as quiet shapes in the product's colours (window, sidebar, header) with only the labels that place the viewer, or the real screenshot behind, dimmed.
- **Nothing else.**

Draw with `addShape` (rounded rectangles), `addTitle` (every label, in the product's typeface or the nearest neutral sans), `addPath` or the real icon files (`addMedia`). Name nodes for what they are (`card.invoice`), group each piece, keep text live.

## Act

One action per shot, on the word that names it, using `tella-ui-interactions`. The cursor is large (4–6% of the frame height), enters from off frame, and its click causes the change on the same frame. Lift the hero piece with a deeper shadow; for camera moves through layers, follow `tella-ui-parallax`. Hand off between shots as `tella-motion-design` says.

## Place

One Tella Motion document per shot at the canvas size (`create_motion_document`), as b-roll (`add_layout` with `media: {type: "motion", documentId}`) or an overlay beside the speaker. Build and check the first shot, then make the rest from it (`duplicate_motion_document`).

## Check

`get_motion_frame` at the start, the click and the held result, and `get_motion_preview`: labels and values match the source crop, text is sharp and readable at phone size, the click causes the change on its frame, and nothing covers the speaker in the video.

Referenced files: 1 — file references are metadata, not package contents.