Doublespeed

View saved version →

---
name: ai-video-editor-projects
description: |
  Build cohesive multi-scene AI videos as editable editor projects through the doublespeed MCP: generate scene clips with available credits, add an ElevenLabs voiceover track, add word-timed captions, and save it all as an /editor project the user can open and edit on the timeline. Use when the user wants an AI video assembled in the editor, a narrated multi-scene video, or MCP-driven video production that stays editable (not a one-shot render).
---

# AI Video Editor Projects

Assemble multi-scene AI videos as real editor projects instead of one-shot renders. Every layer lands on the `/editor` timeline as its own editable item: each scene clip is a video item, the voiceover is an audio item, and captions are caption items with word-accurate timing. The user (or you) can then rearrange, retrim, restyle, and export from the editor, or render via MCP.

Read `doublespeed://skills/ai-video-generation` first for model selection and credits safety; this skill covers the assembly pipeline on top of it.

## Pipeline

1. **Setup**: `whoami`, `set_product` if needed, `context_get_rules`. All steps below are scoped to the active product.
2. **Plan scenes**: agree on scene count, per-scene prompts, and duration with the user before spending credits. Default 9:16 (1080x1920), ~5s clips, 3-6 scenes. For visual continuity across scenes, use image-to-video from a shared reference image or generate each scene's prompt from one consistent style description; models do not carry state between generations.
3. **Generate scenes**: `list_models` for pricing, then `generate_video` per scene (parallel is fine) and poll `check_generation_status` until every clip has a hosted URL. Never switch products to chase credits. Existing footage: `import_media_url` for a direct file URL (mp4/mov/jpg; watch pages like YouTube or TikTok are not downloaded), or `prepare_media_upload` + `commit_media_upload` for local files (both take a `files` batch). Then `import_media_url` with `probe_only: true` for the real duration and dimensions.
4. **Voiceover**: `generate_voiceover` with the narration script (use `list_voices: true` to pick a voice first). Returns a hosted `audioUrl`.
5. **Captions**: `generate_captions` with the voiceover's `audioUrl`. Returns word-level `{ word, start, end }` timings.
6. **Save the project**: `save_editor_project` with the ordered scenes (`video_url` plus `duration_ms` or `trim_ms` each; optional `start_ms`, geometry, `fit`), any `text_items` (native editable headlines), the voiceover, and the caption words. Returns a lean `projectId`, `editorUrl`, and an `items` index (ids + timing) for follow-up patches. Pass `include_composition: true` only when you need the raw composition.
7. **Hand off**: give the user the `editorUrl` as a markdown link. Opening it loads the full composition on the editor timeline.
8. **Check a frame (optional)**: `render_video` with `project_id` and `still_at_ms` returns a PNG of that moment; cheap way to verify layout and text before a full render.
9. **Iterate**: `patch_editor_project` with the item id from `items` to retrim or move one scene, change a headline, swap a motion clip's HTML, or replace captions without resending everything. An open editor tab picks the change up live.
10. **Export (optional)**: call `render_video` with `project_id`; no need to resend the composition. For anything over ~20s or `quality: "high"`, add `background: true`: it returns a `jobId` at once, and `check_generation_status` with `render_job_ids` reports progress and the final `videoUrl` (a synchronous call that outlasts your client's tool timeout reads as a failure even though the render finishes). Or let the user export from the editor after their edits.

## Details that matter

- Scene clips are placed back-to-back in order unless a scene sets `start_ms`. `trim_ms: { from, to }` picks which part of the source file plays (independent of timeline position); `duration_ms` alone means "play the first N ms". Pass `source_duration_ms` (from the probe) so trims past the end of the file are rejected instead of producing black frames.
- Scenes fill the canvas by default (`fit: "cover"`). Use `fit: "contain"` or `"blur-fill"` with `source_width`/`source_height` for mismatched aspect ratios, or set `top`/`left`/`width`/`height` for picture-in-picture layouts.
- `text_items` are native editor text layers (font, size, color, position); prefer them over baking text into video for anything the user may want to reword.
- The voiceover defaults to spanning the whole video from 0. Pass `duration_ms` when the narration is shorter than the scenes so it does not get stretched on the timeline.
- Captions group words into items of 4 by default (`max_words_per_caption` to change). Presets: `stroke` (white text, black outline) and `boxed` (white text on a dark box); override font, size, color, `position` (top/center/bottom) or explicit geometry. Both stay editable per item in the editor.
- Caption `timing` defaults to `timeline` (word times are project times, e.g. from a voiceover). Use `timing: "source"` with `source_url` when the words were transcribed from the scene footage itself: they are then mapped through each scene's trim and placement, so reordering or retrimming scenes keeps captions in sync.
- Update instead of duplicating: pass `project_id` to `save_editor_project` to overwrite an existing project after feedback.
- Preview before showing the user: `render_video_preview` with the returned composition catches pacing and caption-timing problems cheaply.

## Best practices

- Write the narration script first and generate scenes to fit it, not the other way around; timing a script to existing clips almost always needs manual editing.
- Keep narration inside the total scene duration. A 5-scene x 5s video holds roughly 60-70 spoken words.
- Check guardrails (`context_get_rules`, `context_check_content`) before queueing or publishing anything built from the project.

View saved version →

---
name: ai-video-generation
description: |
  Generate AI video clips through the doublespeed MCP: choose a model, submit text-to-video or image-to-video jobs, poll status, and hand the clips to a video draft. Use when the user asks for AI video, generated clips, image-to-video, or video from a prompt.
---

# AI Video Generation via doublespeed

## Setup

1. `whoami` to confirm the active product; `list_products` + `set_product` if wrong or missing.
2. Video generation costs credits and charges the ACTIVE product. On an insufficient-credits error, STOP and report it for the active product - never `set_product` to another product to chase credits. Suggest alternatives: existing collections (`browse_media`), cheaper models, or image-to-video from existing images.

## Workflow

1. **Pick a model.** `list_models` for available video models, parameters, and pricing. Cheaper models are fine for background/demo footage; spend on the hook.
2. **Choose the mode.** Text-to-video for generic scenes; image-to-video when you need a specific product, person, or look (generate or pick the source image first - `generate_image` with `image_url` references keeps a recurring character consistent).
3. **Generate.** `generate_video` per segment (async - returns a media file ID). Submit segments in parallel, then poll `check_generation_status`. Always 9:16, ~5s clips (shorter = better quality).
4. **Prompt for realism.** Candid phone-camera footage, real setting, natural light - not a glossy render. Never ask the model to render text; overlay text is added at the draft stage.
5. **Review every clip** before using it: artifacts, warped hands/faces, and dead first seconds are common. Regenerate rather than shipping a weak clip.
6. **Hand off.** Feed the clip URLs into the hook-demo workflow (`doublespeed://skills/hook-demo-videos`) for overlay text, preview, draft, and posting. For local post-processing (trims, speed ramps, concat via ffmpeg), upload results with `prepare_media_upload` → PUT → `commit_media_upload`.

## Notes

- `generate_image`/`generate_images` follow the same async + credits rules for still images.
- Store keeper images in a collection: `create_image_collection`.
- For research, strategy files, and the feedback loop, read `doublespeed://skills/content-creator`.

View saved version →

---
name: content-creator
description: |
  End-to-end social content creation (TikTok, Instagram, Facebook) through the doublespeed MCP. Pulls brand context and performance data from the MCP, generates media, builds slideshow and video drafts, shares review links, and queues posts. Self-improving: persists strategy, creative assets, and feedback to a local client folder so each session compounds. Use when the user mentions social content, creating posts, researching strategy, generating hooks/captions, making slideshows or video drafts, analyzing what's working, or updating content strategy for any doublespeed product.
---

# Content Creator for doublespeed

Orchestrates the full content pipeline over the doublespeed MCP server (`https://doublespeed.ai/api/mcp`): research, strategy, ideation, production, review, and posting. Stateful and self-improving. Every session reads prior work and builds on it.

Format-specific production steps live in focused companion skills; read the one that matches the task:

- `doublespeed://skills/slideshows` - photo carousels: templates, image generation, scene data, rendering, drafts.
- `doublespeed://skills/hook-demo-videos` - hook + demo videos: segments, overlay text, previews, video drafts.
- `doublespeed://skills/ai-video-generation` - AI clip generation: models, text/image-to-video, credits safety.
- `doublespeed://skills/content-remixer` - repurpose winners into new variants and formats.
- `doublespeed://skills/performance-report` - analytics: aggregates, breakdowns, winner/loser calls.
- `doublespeed://skills/account-creator` - account personas: usernames, bios, search terms, branded or unbranded.

## Environment

- **doublespeed MCP tools**: always available. The core pipeline. All tools are scoped to the ACTIVE product; call `whoami` first and `set_product` if the wrong product (or none) is active.
- **Browser** (Playwright, Chrome extension, or any available browser tool): use for TikTok profile research and trend discovery. TikTok's web UI can be flaky, so keep interactions focused (load profile, scan recent posts, extract text, move on).
- **Local shell (ffmpeg)**: available in shell-capable environments (Claude Code, Codex, Gemini CLI). Use for trimming, speed ramping, concatenating clips. Upload results via `prepare_media_upload` + `commit_media_upload`. If no shell is available, skip local processing and work with generated clips directly.

## Best Practices

### Copy

- Don't freestyle hooks, slide text, or captions from your own head - it comes out generic and AI-sounding. Lift and adapt wording from REAL winning posts (your own top performers via `list_posts`, competitor posts via the browser). Your job is to assemble and adapt proven copy, not to write fresh copy.
- When Skip judge pass is enabled, choose concepts directly without copy or visual judges or a scorer. Otherwise, rank every candidate set with `score_slideshow_copy` before picking; it's trained on this platform's real posted outcomes. It judges copy only - pair it with brand rules (`context_get_rules`) and factual checks.
- Default copy style unless the brand guide says otherwise: write like texting a friend; lead with emotional states, not product features; ALL CAPS on 2-3 trigger words per hook; no em dashes; no trailing period; prefer "my"/"this" over "your"; product mentions read as story plot points, not ads.

### Visuals

- Study full posts, not just words: a post's nuance is in its slide-by-slide STRUCTURE. Mirror a specific real post's structure when in doubt.
- Prompt for realism: candid iPhone/amateur photo, real setting, natural light, grain - not a glossy render. Never ask the model to render text (it garbles it); text comes from overlay blocks.
- The reliable way to hit a specific look (or keep a recurring person consistent across slides) is iterative image-to-image via `generate_image` `image_url`/`image_urls` references, not one-shot text-to-image.
- Never reuse the identical image on multiple slides unless that repetition IS the format.

### Operating discipline

- Distribution is noisy: a good post can flop by chance, and formats often need several reps before the algorithm catches. Read engagement rate (likes/saves/comments relative to views), not just raw views, before killing a format.
- Always preview (`render_slides` / `render_video_preview`) and actually look at the output before saving a draft or posting. Fix weak slides and re-render.
- Attach trending audio when posting slideshows (`music_link` from a winning post in the same lane; staff sessions can also use `search_trending_audio`) - it materially affects reach.
- Repeat review links and hosted media URLs in your reply text as short descriptive markdown links; some clients can't open links from result cards.
- Batch where the API lets you: `generate_images` for all slides at once, `scenes` array in `render_slides`, `variant_ids` in `patch_draft`, `create_posts_bulk` for many posts.

## Client Data (local state)

Client files: `~/Shared drives/doublespeed/doublespeed-clients/{client-name}/`

If the shared drive isn't mounted, tell the user and work from MCP data alone.

### Strategy Files

Each client has a `_strategy/` folder with three files:

```
client-name/
├── _strategy/
│   ├── strategy.md        # Research, content strategy, learnings, performance patterns
│   ├── creative-bank.md   # Proven hooks, prompts, caption patterns
│   └── feedback.md        # Raw user feedback log (dated, categorized)
├── brand docs, briefs...
```

**With account groups** (only when a product has 3+ distinct groups OR the user explicitly works by group): add `group--{name}/` subfolders under `_strategy/`, each with its own three files. Folder naming: `group--{name}` (lowercased, hyphens for spaces). Don't pre-create group folders; create them when the user first works on a specific group.

**strategy.md** combines research, strategy, and learnings in dated sections (`## 2026-03-30` → `### Research`, `### Strategy Updates`, `### Learnings`).

**creative-bank.md** stores proven hooks (grouped by style: stat, bold claim, question, story), image prompts, and video prompts.

**feedback.md** is the raw, dated log: `- hooks: "too aggressive, tone it down" (re: stat hooks batch)`. When feedback repeats 3+ times, promote it to a rule in strategy.md - and if the user wants it enforced, add it as a live guardrail via `context_add_rule`.

### State Rules

1. **Read before you write.** Check `_strategy/` before generating anything.
2. **Append, don't overwrite.** Add dated sections. Mark stale findings explicitly.
3. **Save after meaningful work.** Don't wait until end of session.
4. **Scale effort to the ask.** Quick task = read creative-bank.md + go. Full session = load everything.

## Workflow

### Startup (always)

1. Call `whoami` to see the active product. If it's wrong or missing, `list_products` (use `search`; prefer `recommended: true` when titles duplicate, avoid `isEmpty` shells) then `set_product`. Never switch products on your own initiative afterward.
2. Scale state loading to the task:
   - **Quick task** ("make 3 hooks", "generate an image"): call `get_product` for brand context, read `creative-bank.md` if it exists, proceed.
   - **Content session** ("plan next week's content", "create a batch"): read all `_strategy/` files, call `get_product` + `get_post_metrics`. If using groups, call `list_accounts` to map accounts to groups.
   - **Research/analysis** ("what's working?", "audit our accounts"): full state load + browser research if available.
3. Call `context_get_rules` once per session before producing anything the user may publish. These are live guardrails; they always win over local files.
4. If `_strategy/` doesn't exist, create it as you produce work.

### Research (when needed)

Skip if existing research is fresh and the user isn't asking for new research.

- **Via MCP**: `get_post_metrics` for exact aggregates (totals, averages, per-account performance - no pagination needed). `list_posts` sorted by `viewsCount` (or `list_account_posts` for one account) to study winners and losers; pass `include_scene_data`/`include_image_urls` only when you need slide content. `get_product` for brand state. Staff sessions only: `search_trending_audio` for what sounds are moving (scope `songs` for the ranked chart, `niches` to discover sound niches).
- **Via browser**: visit `tiktok.com/@username` for owned accounts and competitors.
- **Save**: update `strategy.md` with a dated research section.

#### Interpreting post data

Posts carry a type (slideshow vs video). Slideshow rows expose slide text through scene data; videos made in doublespeed carry overlay text in their segments. A video with no overlay text (or created outside doublespeed) is invisible to the MCP - use the browser: open the post, describe visual style, transitions, pacing, on-screen text, and music, and record it in `strategy.md` / `creative-bank.md` as visual references. This is common for celeb-edit and other visual-first accounts; their creative bank should emphasize visual references and mood descriptions over text hooks.

### Content Ideation

1. Start from `creative-bank.md`. Evolve proven hooks/prompts rather than inventing from nothing.
2. Use `get_product` for brand voice and `get_post_metrics` / `list_posts` to see which formats and hooks actually perform.
3. Generate hooks in varied styles (stat, bold claim, question, story) and captions with relevant hashtags.
4. **Choose candidates.** When Skip judge pass is enabled, choose directly without a scoring pass. Otherwise, rank candidates with `score_slideshow_copy`. Send ALL candidate copy sets (slide texts + caption) in ONE call - scores are comparative within the submitted set. Pick from the top, then apply editorial judgment for brand rules and factual accuracy (the scorer knows neither).
5. Check drafts against guardrails with `context_check_content` before presenting them as final.
6. Update `creative-bank.md` with new hooks and prompts.

### Production

Follow the matching companion skill for the full step-by-step:

- **Slideshows** (templates → `generate_images` → `render_slides` → `upsert_slideshow_draft` → `queue_post`): `doublespeed://skills/slideshows`.
- **Hook + demo videos** (segments → overlay text → `render_video_preview` → `upsert_video_draft` → `queue_post`): `doublespeed://skills/hook-demo-videos`.
- **AI clip generation** (`list_models` → `generate_video` → `check_generation_status`, credits safety): `doublespeed://skills/ai-video-generation`.
- **Images**: prefer existing collections (`browse_media`; public pools via `visibility: public`), else `generate_images` for batches / `generate_image` with `image_url`/`image_urls` references for image-to-image consistency. Store keepers with `create_image_collection` + `prepare_media_upload`/`commit_media_upload`.

### Review handoffs

If the user pastes an "Edit with Claude" code from a review page, call `redeem_review_handoff` FIRST (codes are single-use, 10-minute expiry), then edit with `patch_draft` using the returned token.

### Posting

- **From a draft** (preferred - keeps provenance): `queue_post` with the draft's `group_id` or review-link `token` (+ `variant_id` when the draft has several). It uses ONLY the variant's own data; if something's missing, fix the variant with `patch_draft` first.
- **Direct from URLs**: `create_post` with `account_username`, `caption`, and `image_urls` (slideshow) or `video_url` (video); optional `music_link`, `logo_url` (video watermark). For batches, `create_posts_bulk` (≤50 per call).
- Default status `scheduled` queues it into the account's next open slot; these tools cannot pin an exact publish time (only the posting REST API's scheduledAt can, within the account's scheduling rules). Use `draft` if the user wants to review in-app first. Edit caption/account later with `update_post`.
- **Order and timing**: `list_posting_queue` shows each account's queued posts in firing order with their expected `scheduled_at`; `reorder_posting_queue` with the post ids in the wanted order swaps their slots (unnamed posts keep theirs).
- Run `context_check_content` before queueing when the product has guardrail rules.

### Feedback Loop

When the user gives feedback:

1. **Log it** in `feedback.md` with date and category (hooks, overlays, visuals, strategy, general).
2. **Apply it** to the current session immediately.
3. **Promote patterns** to `strategy.md` when the same feedback appears 3+ times.
4. **Make it enforceable** when the user asks for a rule ("never show X", "captions must always Y"): call `context_add_rule` - it goes live immediately. Never route a requested rule through `context_propose_fact` (that only queues a candidate for review).
5. **Update creative-bank.md** if feedback changes what hooks/prompts to use or avoid.

When reviewing performance in a later session:

- `get_post_metrics` for exact aggregates; `list_posts` sorted by views, segmented per account via `account_id` or `list_account_posts`.
- Update `strategy.md` with what over/underperformed and why.
- Periodically push key insights to the product via `update_product` (`notes`, `hook_custom_prompt`, brand-guide fields).

## Tool Reference

| Tool                                                  | Purpose                                                              |
| ----------------------------------------------------- | -------------------------------------------------------------------- |
| `whoami`                                              | Identity, permissions, active product                                |
| `list_products` / `set_product`                       | Find and select the active product                                   |
| `get_product` / `update_product`                      | Brand guide, audience, hooks context; write back insights            |
| `list_accounts` / `get_account` / `update_account`    | Accounts, groups, bios, personas                                     |
| `list_posts` / `list_account_posts`                   | Post rows with views/likes/comments, sortable                        |
| `get_post_metrics`                                    | Exact aggregate performance (totals, averages, per-account)          |
| `search_trending_audio`                               | Ranked trending-sound chart + niche discovery (staff sessions only)  |
| `score_slideshow_copy`                                | Rank candidate slideshow copy when judging is enabled                 |
| `list_models`                                         | Image/video generation models, params, pricing                       |
| `generate_image` / `generate_images`                  | AI images (text-to-image, image-to-image); costs credits             |
| `generate_video` / `check_generation_status`          | Async video generation + polling                                     |
| `list_templates` / `get_template` / `create_template` | Slideshow/video scene templates                                      |
| `list_style_presets`                                  | Canonical text style presets (video: tiktok-sans/tiktok-stroke only) |
| `render_slides`                                       | Preview slides from sceneData (up to 8 scenes per call)              |
| `render_video_preview` / `render_video`               | Baked video preview / full Remotion render                           |
| `upsert_slideshow_draft` / `upsert_video_draft`       | Persist drafts, `createShareLink` for reviewUrl                      |
| `get_draft` / `patch_draft`                           | Inspect and surgically edit draft variants                           |
| `redeem_review_handoff`                               | Open a draft from an "Edit with Claude" code                         |
| `create_review_link`                                  | Separate review-link step (prefer createShareLink)                   |
| `create_combined_review_link`                         | One review link covering 2-25 saved drafts                           |
| `queue_post`                                          | Queue a draft variant as a post                                      |
| `create_post` / `create_posts_bulk` / `update_post`   | Direct posting from URLs; edit/reschedule                            |
| `browse_media` / `create_image_collection`            | Media library folders and files                                      |
| `prepare_media_upload` / `commit_media_upload`        | Upload local files (SAS PUT flow, batches supported)                 |
| `import_media_url`                                    | Import a direct media URL; `probe_only` just reads its metadata      |
| `context_get_rules` / `context_check_content`         | Guardrails: read rules, pre-publish check                            |
| `context_add_rule`                                    | Add a LIVE guardrail rule when the user asks for one                 |

View saved version →

---
name: content-remixer
description: |
  Repurpose winning content into new posts through the doublespeed MCP: find top performers, extract what worked, and remix it into fresh variants and formats (new copy on a proven structure, new imagery on a proven layout, slideshow to video and back). Use when the user asks to remix, repurpose, iterate on a winner, make variants, or "more like this".
---

# Content Remixer via doublespeed

Remixing beats freestyling: a proven structure with fresh skin outperforms a new idea most days. This skill turns one winner into many posts.

## Setup

1. `whoami` to confirm the active product; `list_products` + `set_product` if wrong or missing. Never switch products on your own initiative afterward.
2. `context_get_rules` once per session; check final copy with `context_check_content` before queueing.

## Find the winner

1. `get_post_metrics` for the exact aggregate picture (per-account and per-format performance, engagement rate vs raw views).
2. `list_posts` sorted by `viewsCount` (add a date range to catch recent breakouts); pull the winner's full structure with `include_scene_data`.
3. For outside inspiration, study competitor posts in the browser (staff sessions can also check `search_trending_audio` for what's rising in the niche). Judge winners on engagement rate (likes/saves/comments relative to views), not views alone - one lucky post is not a format.

## Remix moves

Pick the lightest move that produces a genuinely different post:

1. **Same structure, new copy.** Keep the winning post's slide-by-slide structure; swap hook, body text, and caption. Generate several copy sets and adapt wording from other real winners. When Skip judge pass is enabled, choose directly without copy or visual judges or a scorer. Otherwise, rank them ALL in one `score_slideshow_copy` call.
2. **Same copy, new visuals.** Regenerate imagery with `generate_images`; to keep a recurring person or match the original look, use image-to-image via `generate_image` with `image_url`/`image_urls` references to the winner's media (`browse_media` to find it).
3. **Promote the winner to a template.** `create_template` from the winning scene_data (preview with `render_slides` first) so every future draft inherits the structure with proper `sourceTemplateId` lineage.
4. **Cross-format.** Slideshow winner -> video: reuse its hook as video overlay text and generate footage per `doublespeed://skills/ai-video-generation`, then build the draft per `doublespeed://skills/hook-demo-videos`. Video winner -> slideshow: turn its beats into slides per `doublespeed://skills/slideshows`.
5. **Audio refresh.** Re-queue a proven post with new trending audio: the `music_link` from a current winner in the same lane (staff sessions can also use `search_trending_audio`).
6. **Full video recreation.** The REST `/api/v1/clone` endpoint (separate `ds-` API key, not an MCP tool) recreates a source video as a fresh AI generation, optionally featuring the product.

## Ship

1. Preview every remix (`render_slides` / `render_video_preview`) and actually look at it - a remix that reads like a re-upload is wasted.
2. Save with `upsert_slideshow_draft` / `upsert_video_draft` (`createShareLink: true`), iterate with `patch_draft` (use `variant_ids` to apply one edit across many variants).
3. Spread variants across accounts with `queue_post` or `create_posts_bulk`; never post identical content to the same account twice.

## Notes

- Repeat review links and hosted media URLs in your reply as short descriptive markdown links.
- Log which remix moves win into the strategy files described in `doublespeed://skills/content-creator`.

View saved version →

---
name: hook-demo-videos
description: |
  Build hook + demo videos for TikTok, Instagram, and Facebook through the doublespeed MCP: plan segments, source or trim clips, add overlay text, render a baked preview, save an editable video draft with a review link, and queue the post. Use when the user asks for hook videos, demo videos, video edits, or overlay-text videos.
---

# Hook + Demo Videos via doublespeed

A hook-demo video pairs a scroll-stopping opener (the hook) with product/demo footage. It is the most common doublespeed video format and stays editable in the bulk-video table after saving.

## Setup

1. `whoami` to confirm the active product; `list_products` + `set_product` if wrong or missing. Never switch products on your own initiative afterward.
2. `context_get_rules` once per session; check final copy with `context_check_content`.
3. `get_product` for the brand guide and voice.

## Workflow

1. **Plan structure.** Single clip, hook+demo (most common), or multi-segment. Decide per segment whether footage comes from the media library, AI generation (see `doublespeed://skills/ai-video-generation`), or a local file.
2. **Source clips.** Library: `browse_media`. Local files or ffmpeg output (trims, speed ramps, concatenation in shell-capable environments): `prepare_media_upload` → HTTP PUT the bytes to the SAS URL → `commit_media_upload` for the durable URL. Always 9:16.
3. **Write overlay text.** Lift and adapt hooks from real winning posts (`list_posts` sorted by `viewsCount`), not from your own head. Default style unless the brand guide says otherwise: texting-a-friend voice, emotional states over features, ALL CAPS on 2-3 trigger words, no trailing period, "my"/"this" over "your".
4. **Preview.** `render_video_preview` with `videoUrl` (or `clips`), `textBlocks`, and `editorDimensions: 1080x1920`. Video overlay text may ONLY use `stylePreset` `tiktok-sans` or `tiktok-stroke`. Watch the output before saving: readable text, clean pacing, hook lands in the first second.
5. **Save the draft.** `upsert_video_draft` with `videos` (review rows), `hookDemoState` (rows, segments, text blocks - the editable source of truth), and `createShareLink: true` for the reviewUrl.
6. **Iterate.** `get_draft` → `patch_draft` with `segment_edits` (text, styling, overlays, filters, trim/speed), `text_block_inserts` to ADD overlay text, plus leaf fields (`caption`, `music_link`, `mute_music`, `account_id`).
7. **Post.** `queue_post` with the draft's `group_id` or review-link `token` (+ `variant_id` when several). Or post directly from a URL with `create_post` (`video_url`, optional `music_link`, `logo_url` watermark); batches via `create_posts_bulk` (≤50).

## Audio

Trending audio helps videos too. Reuse a winning post's `music_link` (staff sessions can also use `search_trending_audio`); attach it with `music_link` on `upsert_video_draft`/`patch_draft` (or `create_post`). Use `mute_music`/`music_volume`/`video_volume` via `patch_draft` to balance it against the clip's own sound.

## Notes

- `render_video` does a full Remotion composition render; prefer `render_video_preview` + `upsert_video_draft` when the video should stay editable.
- Repeat the reviewUrl in your reply text as a short descriptive markdown link.
- If the user pastes an "Edit with Claude" code, call `redeem_review_handoff` FIRST (single-use, 10-minute expiry), then `patch_draft` with the returned token.
- For research, strategy files, and the feedback loop, read `doublespeed://skills/content-creator`.

View saved version →

---
name: performance-report
description: |
  Analyze posting performance through the doublespeed MCP and turn it into decisions: exact aggregates, per-account and per-format breakdowns, winner/loser calls, and a written report. Use when the user asks what's working, for analytics, a performance report, account health, or what to post more of.
---

# Performance Report via doublespeed

## Setup

1. `whoami` to confirm the active product; `list_products` + `set_product` if wrong or missing. Never switch products on your own initiative afterward.

## Gather

1. **Aggregates first.** `get_post_metrics` returns exact totals, averages, medians, maximums, engagement, and per-account performance across the full filtered post set in one call - use it for every numeric claim instead of paginating and summing yourself. Filter by date range to compare periods.
2. **Ranked posts.** `list_posts` sorted by `viewsCount` (or date) for the top and bottom performers; pull `include_scene_data` only for the handful you'll dissect.
3. **Per-account drilldown.** `list_account_posts` for one account's history; `get_account` / `list_accounts` for status (good, warming, burned) and profile setup.

## Analyze

- Judge on **engagement rate** (likes/saves/comments relative to views), not raw views: distribution is noisy and one lucky post is not a format.
- Cut by format (slideshow vs video), hook style, account, and posting time. A format needs several reps before the algorithm catches - do not kill it on one flop.
- Dissect the top 3-5 winners' actual structure (hook wording, slide order, audio) - that nuance is the actionable part, not the numbers.
- Note account health: burned or inactive accounts drag averages; flag them rather than blending them in.

## Report

1. Write a short report: what won and why (with post links), what lost, per-account calls (double down / fix profile / rest), and 3-5 concrete next posts.
2. Persist findings into the strategy and feedback files described in `doublespeed://skills/content-creator` so the next session builds on them.
3. Turn "more of what works" into action with `doublespeed://skills/content-remixer`.

## Notes

- Repeat post and review links in your reply as short descriptive markdown links.
- Numbers come from `get_post_metrics`; never estimate from a sampled page of posts.

View saved version →

---
name: slideshows
description: |
  Build slideshow (photo carousel) posts for TikTok, Instagram, and Facebook through the doublespeed MCP: pick a template, generate images, edit scene data, render previews, save a draft with a review link, and queue the post. Use when the user asks for slides, carousels, slideshows, or image posts.
---

# Slideshows via doublespeed

## Setup

1. `whoami` to confirm the active product; `list_products` + `set_product` if wrong or missing. Never switch products on your own initiative afterward.
2. `context_get_rules` once per session before producing anything the user may publish; check final copy with `context_check_content`.
3. `get_product` for the brand guide and voice.

## Workflow

1. **Pick a template.** `list_templates` to browse, `get_template` for the winner's `scene_data` and variables. Prefer templates that performed well historically (`list_posts` sorted by `viewsCount`). To preview all its slides, pass its scene_data to `render_slides`.
2. **Generate images.** `generate_images` (plural - all slides in ONE parallel call, `async: true`), then poll `check_generation_status`. Check `list_models` for image models. Or reuse library images via `browse_media` (public pools via `visibility: public`).
   - Prompt for realism: candid iPhone/amateur photo, natural light, grain - not a glossy render. Never ask the model to render text; text comes from overlay blocks.
   - To keep a recurring person or match a specific look across slides, use iterative image-to-image via `generate_image` with `image_url`/`image_urls` references.
   - Never reuse the identical image on multiple slides unless that repetition IS the format.
3. **Edit the template's sceneData in place.** Change only text content, image `src`, and per-slide `color`/`bounds`. Keep the template's fontFamily/fontWeight/fontSize/lineHeight/letterSpacing exactly as fetched - drafts from a template product are rejected otherwise. Style text blocks by naming a preset (`style.stylePreset` from `list_style_presets`; usually `tiktok-stroke` or `tiktok-bg`), never by restating the preset's own values. Keep text inside the platform safe area (on 1080x1920: x 46-1033, y 115-1545, clear of the action rail).
4. **Choose the copy.** When Skip judge pass is enabled, choose directly without copy or visual judges or a scorer. Otherwise, send ALL candidate copy sets (slide texts + caption) to `score_slideshow_copy` in ONE call - scores are comparative within the submitted set. Pick from the top, then apply brand rules and factual checks (the scorer knows neither). Lift and adapt wording from real winning posts rather than freestyling.
5. **Preview.** `render_slides` with the sceneData (or `scenes` array for up to 8 variants in one call). Treat `warnings` as unreadable slides; fix and re-render. Actually look at the output: does slide 1 stop the scroll?
6. **Save the draft.** `upsert_slideshow_draft` with the SAME sceneData, `sourceTemplateId` (required lineage when the product has templates), and `createShareLink: true` to get the `reviewUrl` in one call. Omit `groupId` to create; include it to update.
7. **Iterate.** `get_draft` (summary mode) to read blocks, `patch_draft` with `block_edits` (text, images, styling, position) or `structure_edits` (add/remove/reorder pages). Prefer these narrow helpers over resending sceneData; use `variant_ids` to apply one edit across many variants in a single call.
8. **Post.** `queue_post` with the draft's `group_id` or review-link `token` (+ `variant_id` when several). Audio must already be on the draft (see Audio). Run `context_check_content` before queueing when the product has rules.

## Audio

Every slideshow should ship with trending audio; it materially affects reach and no tool adds it for you.

1. Find a track: copy the `music_link` from a winning post in the same lane (`list_posts` sorted by `viewsCount`). Staff sessions can also use `search_trending_audio` (scope `songs` for the ranked chart, `niches` for sound niches).
2. Attach it: `music_link` on `upsert_slideshow_draft`, or `patch_draft` with `music_link` on an existing draft. The link must be a TikTok or Instagram share URL matching the account's platform.
3. `queue_post` returns a `warnings` entry when a slideshow has no audio. Treat it as a blocker unless the user said no music.

## Notes

- Repeat the reviewUrl and hosted media URLs in your reply text as short descriptive markdown links; some clients can't open links from result cards.
- If the user pastes an "Edit with Claude" code from a review page, call `redeem_review_handoff` FIRST (single-use, 10-minute expiry), then edit with `patch_draft` using the returned token.
- For research, strategy files, and the feedback loop, read `doublespeed://skills/content-creator`.