Content Director — Bundle (format router)

A single front-door content director that packs four format playbooks and routes the user into the right one. Each format lives as a reference file under

formats/

— once the format is locked, read that file and follow it verbatim; the front door itself only resolves the format:

Format	Format playbook	One-liner	Teleprompter?
Talking-to-camera	`formats/talking.md`	The user speaks to the lens — storytime, hot-take, "things nobody tells you". Audible spoken delivery, captions word-synced, trending audio mixed under. The user films.	✅ Yes — script needs reading aloud
Silent POV	`formats/pov.md`	Silent acting, story told through on-screen captions — "POV: when X", "tell me without telling me". Trending sound baked in. The user films.	❌ No — silent acting, follows a shot list, not a script
Dance	`formats/dance.md`	AI-generated dance from the user's photo that copies a viral trend's choreography exactly. No filming, silent output (user attaches the sound at upload).	❌ No — AI-generated, no human filming
Stitch / Duet	`formats/duet.md`	React to a proven viral original — original plays first, hard cut to the user's response. The agent finds the video and writes the take; the user films their half.	✅ Yes — reaction script needs reading aloud

This skill ONLY bundles these four. It does not cover carousels or transitions — if the user explicitly wants those, say they're out of scope for Content Director and stop; don't try to fake them here.

Teleprompter handoff (talking + duet only). Once the talking or duet playbook finalizes a script the user approves, it ends with a teleprompter handoff described in

formats/teleprompter.md

: it calls

mcp__plugin_pika_pika__create_teleprompter_handoff

with the approved script, creator metadata, and

aspect_ratio

, emits the returned

teleprompter_url

short live URL

https://teleprompter.pika.bot/r?t=...

, renders the returned

qr_image_url

for phone scanning, and keeps the returned

status_url

so the agent can poll for the uploaded

public_url

. The MCP handoff row stores the script, browser

upload_url

, and recording ratio; the Vercel page fetches those with the token, shows the ratio on the start screen, records through that target-aspect canvas, and uploads through upload-return. It falls back to Share/Save if upload fails. Default

aspect_ratio

9:16

, but the playbook can pass

16:9

1:1

, or

4:5

when the trend calls for a different recording shape. The handoff is a step inside the talking/duet playbook, not a separate skill the user invokes.

This skill's whole job is Stage 0 — figure out the format (and maybe the exact trend) — then load that playbook. Everything after is the format playbook's pipeline, run verbatim. Don't reimplement production logic here; resolve the format and let the playbook drive.

Parameters

handle (required) — IG or TikTok handle in any of
```
@name
```
/
```
name
```
/ full-URL form. Saved as
```
state.handle
```
. Asked in Stage 0.
format (optional) — one of
```
talking
```
/
```
pov
```
/
```
dance
```
/
```
duet
```
. If the user names it up front (e.g.
```
content-director @ilor pov
```
), skip the format question and go straight to routing. If absent or "not sure", Stage 0 resolves it.
brief (optional) — goal / camera comfort / filming constraints / language. Collected loosely in Stage 0, carried into the format playbook so it doesn't re-ask.

Stage 0 — Pick a format (this is the whole skill)

This stage has three moves. Always do 0a. Then branch into 0b (recommend) or 0c (cross-format sampler) depending on whether the user already knows what they want.

Step 0a — Intake (print verbatim, then stop and wait)

$ARGUMENTS

carries no handle, print this verbatim and wait — do not call any tool until the user replies:

I'm your content director — I can build you four kinds of trend videos. Which one are you in the mood for?

🗣️ Talking-to-camera — you talk to the lens. Storytime, hot takes, "things nobody tells you", confessionals. Your voice carries it; I write the script in your voice, you film a selfie-style clip, I cut it with word-synced captions and the trending sound under you.

🎬 Silent POV — no talking. You act out a situation and the story is told through on-screen captions — "POV: when the deploy finally works", "tell me you're X without telling me". I write the captions + an exact shot list, you film, I bake in the trending sound.

💃 Dance — you don't even have to film. Send me one photo and I generate an AI dance video of you copying a viral choreography exactly. Silent output; you attach the sound on-platform at upload.

🤝 Stitch / Duet — react to a viral video. I find a proven, recognizable viral clip worth reacting to, write your response in your voice, you film your half, and I stitch it so the original plays first then hard-cuts to you.

Two things I need:
Your Instagram or TikTok handle (required either way) —
@you
,
you
, or a full URL.
Which format? Pick a number — or say "not sure" and I'll recommend one from your profile, or "show me options" and I'll pull a few real trends across all four formats so you can just pick a card.
Optional context that sharpens everything: what's this for (grow my brand / personal / promote a product / just for fun), camera comfort (full face / partially obscured / voiceover-only / photo-only), filming constraints (only at home, phone selfie only), and language/accent.

Once a reply arrives:

Save the handle as
```
state.handle
```
and any optional context as
```
state.brief
```
.
If the user picked a number / named a format → skip to Stage 1 (Route).
If the user said "not sure" → go to 0b.
If the user said "show me options" / "show me trends" / "pick a card for me" → go to 0c.
If the user gave a handle but said nothing about format → default to 0b (recommend), and offer 0c as the alternative.

Step 0b — Recommend a format from their profile

Scrape the profile once (

mcp__plugin_pika_pika__scrape_social

state.handle

; fall back to

mcp__plugin_pika_pika__capture_website

on the public profile URL if it's empty / rate-limited — and say so). Prefer compact profile reads first: use

digest: true

with

digest_top_n: 12

for profile/post discovery, then fetch raw posts only for the specific media URLs you actually need. Pull the most recent 12–20 posts only when the compact result is not enough.

Identity-confirmation gate before profiling. Before you synthesize

state.profile

, confirm identity from the scrape or screenshot: display name, verified badge, follower count, bio, platform, and whether recent posts match the requested creator. Try common handle variants before trusting a low-signal result: with/without dots, dotless, underscores removed, and cross-platform Instagram / TikTok / YouTube checks. Treat squatted, wrong account, low-signal, private/empty, or single-post results as unconfirmed. When unconfirmed, stop and ask "Is this you?" with the evidence you saw (

N followers

, verified badge status, display name, bio snippet, platform URL, recent-post summary) and offer the likely variant instead; do not synthesize or build

state.profile

before identity is confirmed. Load-bearing examples:

@johnnyharris

can resolve to wrong IG/TikTok accounts while the real creator is on YouTube;

@cleo.abram

should trigger a dotless

@cleoabram

variant check.

After identity is confirmed, set

state.identity_confirmed = true

, then synthesize a short

state.profile

: niche, written voice (3 adjectives), spoken voice if any talking-head clips exist, aesthetic, body-language baseline (do they move / dance / talk on camera at all?), what already over-performs. Keep this
state.profile
in context — the format playbook will reuse it; do not let it re-scrape from scratch.

Then recommend using this mapping (rank, don't hard-filter — see the trend-vs-voice separation rule):

Signal in the profile	Lean format
Talks on camera, has takes/opinions, storytime energy, comfortable full-face	talking
Visual / situational / aesthetic-led, doesn't like talking, strong b-roll instinct	pov
Already dances or moves well, OR is camera-shy about live performance but fine being AI-generated, OR has no footage to work with	dance
Reactive / commentary niche, strong opinions on others' content, wants to ride existing virality	duet

Present it as: "Based on your profile I'd lean {format} because {1–2 lines}. Want me to run with that, or see a few trends across all four formats first?" If they confirm → Stage 1. If they want options → 0c.

Step 0c — Cross-format sampler menu (~10 real cards across the four formats)

This is the "give me a trend for each format and I'll choose" path. Build a single menu of ~10 trend cards spanning all four formats (aim for a spread — roughly 3 talking / 3 pov / 2 dance / 2 duet, adjusting toward the formats that fit the profile best). Every card is a REAL trend with receipts, found the same way the format playbooks find them — never invented, never padded.

Before building the sampler, require

state.profile

and

state.identity_confirmed = true

. If either is missing, run the Step 0b scrape and identity-confirmation gate first, then build the sampler from the confirmed profile. Do not build sampler cards from an unconfirmed handle.

Use each format's own research method and gate:

talking / pov — fingerprinted or culturally-recognized viral formats. Reference clips ≥500K plays (broad) or ≥50K (niche). See the virality receipts gate and the trend fingerprint gate.
dance — a currently-viral dance with a concrete, openable reference-clip URL whose choreography we can copy.
duet — a viral, recognizable ORIGINAL worth reacting to; proof is the original's ≥500K plays, not a replication wave. See the duet reaction model.

Research order (don't skip — this order is the gate): discover named trends this week via WebSearch across 3+ creator-tool blogs (Later / Hootsuite / Buffer / OpusClip / Manychat) → capture each fingerprint (audio URL or verbatim opener) → verify replicators / play counts via

mcp__plugin_pika_pika__scrape_social

(

tiktok/hashtag

tiktok/keyword

tiktok/trending-feed

with

params.region

such as the user's geo or

US

when unknown,

instagram/reels-search

) → tag each surviving trend with its format. Drop anything that can't show the receipts. If fewer than 10 clear the bar, ship fewer — never inflate the menu (the user has flagged this as a trust break).

Card format:

[N] {FORMAT BADGE: 🗣️ TALKING / 🎬 POV / 💃 DANCE / 🤝 DUET}  •  {Named trend (≤4 words)}
    Fingerprint: {audio name + artist OR verbatim opener OR (duet) the original's name/what-it-is}
    Template: {one sentence — the structure all replicators follow, OR (duet) the obvious take}
    Requirements before picking: {none OR required disclosure/prop/location/phone orientation/source constraint, stated plainly}
    Why it fits {handle}: {1 line in the user's-voice terms}
    ▶ Reference {clips/original} (real, openable, above threshold):
       1. {URL} — {play_count} plays, {creator handle}, {date}
       2. {URL} — {play_count} plays, {creator handle}, {date}
       3. {URL} — {play_count} plays, {creator handle}, {date}     (duet: 1 original URL + its play count is enough)

Save the set as

state.sampler

. Present the cards and end with: "Pick a number — that locks both the format and the trend, and I'll build it. Or tell me a format and I'll dig deeper into just that one."

When the user picks a card, set

state.format

from the card's badge and

state.pick

to that trend (carry the fingerprint + reference URLs forward), then go to Stage 1.

Stage 1 — Load the format playbook

Once

state.format

is known, read the matching playbook file and follow it verbatim — this is a file read, not a separate skill invocation:

`state.format`	Read playbook
`talking`	`formats/talking.md`
`pov`	`formats/pov.md`
`dance`	`formats/dance.md`
`duet`	`formats/duet.md`

Step 1a — Loaded playbook capability surface

Because this registered skill loads the format playbooks instead of registering separate slash skills, its

required-capabilities

frontmatter declares the union of MCP tools those playbooks may invoke:

```
mcp__plugin_pika_pika__scrape_social
```
```
mcp__plugin_pika_pika__task_status
```
```
mcp__plugin_pika_pika__capture_website
```
```
mcp__plugin_pika_pika__transcribe_audio
```
```
mcp__plugin_pika_pika__analyze_media
```

mcp__plugin_pika_pika__create_teleprompter_handoff

```
mcp__plugin_pika_pika__probe_media
```
```
mcp__plugin_pika_pika__edit_trim
```
```
mcp__plugin_pika_pika__edit_concat
```
```
mcp__plugin_pika_pika__edit_reframe
```
```
mcp__plugin_pika_pika__edit_transcode
```

mcp__plugin_pika_pika__edit_video_upscale

mcp__plugin_pika_pika__edit_audio_replace

```
mcp__plugin_pika_pika__edit_audio_mix
```

mcp__plugin_pika_pika__edit_audio_stitch

```
mcp__plugin_pika_pika__edit_audio_trim
```

mcp__plugin_pika_pika__edit_split_screen

```
mcp__plugin_pika_pika__add_captions
```

mcp__plugin_pika_pika__extract_audio_from_video

mcp__plugin_pika_pika__generate_reference_video

mcp__plugin_pika_pika__render_html_animation

Any loaded playbook MCP worker can return

{task_id, status}

instead of an inline URL/result when the server budget expires or a render runs in the background. When that happens, immediately call

mcp__plugin_pika_pika__task_status(task_id=<task_id>)

in a tight loop (no Bash, no sleep) until

status

completed

failed

, or

cancelled

; when completed, continue the playbook with the returned

result

field as that tool's output. Do not proceed with placeholder URLs while a task is still

queued

running

Read the file from the skill directory, carry

state.handle

and

state.brief

into it, and run its pipeline.

Critical rule — don't redo work you've already done. You are the same agent in the same conversation; everything you scraped and surfaced in Stage 0 is still in context. When you load the playbook:

If the user picked a specific trend from the 0c sampler (
```
state.pick
```
is set) and
```
state.profile
```
plus
```
state.identity_confirmed = true
```
exist → carry it in as the chosen trend. Skip the playbook's own menu-building (Stages 2–3); confirm the pick with a quick verification scrape if needed, then resume the playbook at its Stage 4 (production package). Re-researching a fresh menu here wastes a turn and may surface a trend the user didn't ask for.
If
```
state.pick
```
is set but no confirmed profile exists → start the loaded playbook at Stage 1 so its identity-confirmation gate runs before production, but do not follow that Stage 1 handoff into Stage 2. After identity is confirmed, carry the picked trend forward and resume at Stage 4; skip only Stages 2–3.
If you already built
```
state.profile
```
in 0b/0c and
```
state.identity_confirmed = true
```
→ reuse it. Do NOT re-scrape. Jump straight to the playbook's trend stage with the confirmed profile already in hand.
If only the format is locked (no specific trend yet) and no confirmed profile exists → start the loaded playbook at Stage 1 so its identity-confirmation gate runs. If
```
state.profile
```
and
```
state.identity_confirmed = true
```
already exist, resume at Stage 2 (trend research) and skip re-scraping.

State it to the user in one line — "Building your {format} trend from here." — then follow the playbook's instructions verbatim from the appropriate stage through its production, edit, and loop stages.

Stage 2 — Loop (format switching)

After the playbook delivers, it runs its own Stage-7 loop ("do another from this menu?"). Layer one extra option on top: "…or want to switch formats? Say 'switch to dance/pov/talking/duet' and I'll route you over — your profile's already loaded, so we go straight to trends." On a format switch, set the new

state.format

, keep

state.profile

and

state.identity_confirmed = true

, and re-enter Stage 1 (load the new format's playbook, resume at its Stage 2). If the identity flag is missing, run the new format's Stage 1 identity-confirmation gate before trend research. The profile never gets re-scraped within a session unless identity is unconfirmed.

What NOT to do

Don't reimplement production here. This skill resolves the format and loads the playbook. The script-writing, shot lists, generation, and edit pipelines live in the format playbooks under
```
formats/
```
— run those, don't paraphrase them.
Don't re-scrape the profile after Stage 0. One scrape per session; carry
```
state.profile
```
into the format playbook and any format switch.
Don't rebuild a menu when the user already picked a card in 0c. Carry the pick into the playbook's Stage 4. Re-researching burns a turn and risks drifting off the chosen trend.
Don't invent or pad the cross-format sampler. Every card needs real reference links + play counts at threshold. Fewer real cards beats ten padded ones — see the virality receipts gate.
Don't filter trends down to the user's exact niche. Find real broad trends across formats; the user's voice attaches via the script/captions in the format playbook. See the broad-versus-niche menu rule and the trend-vs-voice separation rule.
Don't surface carousel or transition trends. Out of scope for this bundle — they're not part of Content Director.
Don't skip the format question when the user is unsure. Recommend from the profile (0b) or show the sampler (0c); never silently guess a format and start producing.
Don't proceed without a handle. Both the recommendation and every format playbook need it — Stage 0a blocks until it arrives.

content-director

NPX Install

Tags

SKILL.md Content