Abhi5415/instagram-reels

Instagram Reels Production

End-to-end workflow for producing and publishing an Instagram Reel. These are not cross-posts — they're remixed versions of TikTok concepts: same psychology insight, but a deeper/longer script tailored for Instagram's audience, new voiceover, and additional illustrations to support the expanded content.

Workflow with Approval Gates

CRITICAL: Do NOT publish to Instagram without explicit user approval of the rendered video. Show them the video file path and wait for "go" before uploading/publishing.

Phase 0: Performance Analysis & Hypothesis Formation (automated)

Before creating ANY new reel, analyze all prior reels to understand what's working, form a testable hypothesis, and structure the new content as an experiment.

Step 1: Pull metrics for all prior reels

Use the Meta Graph API to fetch performance data for every published reel. The Instagram Business Account ID is 17841477134994858.

Get all media IDs:

pipenv run python3 -c "
import requests, os
from dotenv import load_dotenv
load_dotenv()
token = os.getenv('META_ACCESS_TOKEN')
account_id = '17841477134994858'
url = f'https://graph.facebook.com/v21.0/{account_id}/media'
params = {'fields': 'id,caption,timestamp,media_type,media_url,permalink', 'access_token': token, 'limit': 50}
r = requests.get(url, params=params)
data = r.json()
for m in data.get('data', []):
    if m.get('media_type') == 'VIDEO':
        print(f\"{m['id']} | {m['timestamp'][:10]} | {m.get('permalink','')} | {m.get('caption','')[:60]}\")
"

For each reel, fetch insights:

# Key metrics for each media_id:
pipenv run python3 -c "
import requests, os
from dotenv import load_dotenv
load_dotenv()
token = os.getenv('META_ACCESS_TOKEN')
media_id = 'MEDIA_ID_HERE'
url = f'https://graph.facebook.com/v21.0/{media_id}/insights'
params = {
    'metric': 'ig_reels_avg_watch_time,ig_reels_video_view_total_time,reach,views,likes,saved,shares,comments,total_interactions',
    'access_token': token
}
r = requests.get(url, params=params)
for m in r.json().get('data', []):
    print(f\"{m['name']}: {m['values'][0]['value']}\")
"

Get video duration via ffprobe (the IG API does not return video_duration reliably):

ffprobe -v error -show_entries format=duration -of csv=p=0 "MEDIA_URL_HERE"

Step 1b: Check paid promotion status

Some reels may be boosted with ad spend. Pull all active and recent Instagram Reel promotion campaigns from the Meta Marketing API to understand which reels have paid reach inflating their numbers.

Get all ads promoting Instagram Reels:

pipenv run python3 -c "
import requests, os, json
from dotenv import load_dotenv
load_dotenv()
token = os.getenv('META_ACCESS_TOKEN')
ad_account = os.getenv('META_AD_ACCOUNT_ID')  # act_217614761779242

# Get all campaigns (active + paused + completed)
url = f'https://graph.facebook.com/v21.0/{ad_account}/campaigns'
params = {
    'fields': 'id,name,status,objective',
    'filtering': json.dumps([{'field': 'name', 'operator': 'CONTAIN', 'value': 'Instagram Reel'}]),
    'access_token': token,
    'limit': 50
}
r = requests.get(url, params=params)
campaigns = r.json().get('data', [])

for c in campaigns:
    print(f\"Campaign: {c['name']} | Status: {c['status']} | ID: {c['id']}\")

    # Get adsets under this campaign
    adsets_url = f'https://graph.facebook.com/v21.0/{c[\"id\"]}/adsets'
    adsets_params = {'fields': 'id,name,daily_budget,status', 'access_token': token}
    adsets = requests.get(adsets_url, params=adsets_params).json().get('data', [])

    for a in adsets:
        budget = int(a.get('daily_budget', 0)) / 100
        print(f'  Adset: {a[\"name\"]} | \${budget:.0f}/day | Status: {a[\"status\"]}')

        # Get ads + spend/reach
        ads_url = f'https://graph.facebook.com/v21.0/{a[\"id\"]}/ads'
        ads_params = {'fields': 'id,name,status,insights{spend,reach,impressions,actions}', 'access_token': token}
        ads = requests.get(ads_url, params=ads_params).json().get('data', [])
        for ad in ads:
            insights = ad.get('insights', {}).get('data', [{}])[0]
            spend = insights.get('spend', '0')
            reach = insights.get('reach', '0')
            print(f'    Ad: {ad[\"name\"]} | Spend: \${spend} | Paid Reach: {reach} | Status: {ad[\"status\"]}')
    print()
"

Why this matters: A reel's organic reach/saves numbers may be inflated by paid promotion. When comparing reels, note which ones had paid support and separate organic vs paid performance. A reel with 2,000 reach and $0 spend is very different from one with 2,000 reach and $50 spend.

What to include in the performance table: Add columns for Paid Spend and Paid Reach (or $0 / organic only for unboosted reels). When a reel is currently being promoted, note it as ACTIVE $X/day.

Step 2: Calculate retention rates

For each reel, compute: retention % = (ig_reels_avg_watch_time_ms / 1000) / video_duration_seconds * 100

Note on paid vs organic retention: The ig_reels_avg_watch_time metric from the IG API is a blend of organic and paid viewers. Paid viewers typically have lower retention (they didn't choose to see your content). If a reel is being promoted, its retention % may be dragged down by paid traffic. Keep this in mind when comparing promoted vs unpromoted reels.

Step 3: Analyze content attributes

For each reel, classify these attributes (read the corresponding brief.md and Remotion config.ts):

| Attribute | How to measure | Why it matters | |-----------|---------------|----------------| | Hook type | Read first slide text/voiceover. Classify as: identity/scenario, factoid/historical, contrarian, numbered-list, curiosity-gap | Identity hooks outperform factoid hooks 5-13x in our data | | First slide duration | Read config.ts slide definitions, calculate first slide duration in seconds | First slides under 3s correlate with higher retention | | Emotional valence | Read the hook. Classify as: neutral, negative, positive | Neutral valence hooks outperform negative valence hooks | | Total slides | Count slide definitions in config.ts | More slides = more visual variety = more retention | | Average pacing | video_duration / total_slides | 3.0-3.5s avg pacing correlates with best retention | | Video duration | ffprobe measurement | Shorter videos may retain better (but sample size is small) | | Has CTA | Check if voiceover mentions Clarido | Product CTAs may affect retention/saves |

Step 4: Build the performance table

Compile all metrics into a single comparison table:

| Reel | Date | Retention | Reach | Saves | Paid Spend | Paid Reach | Hook Type | Valence | 1st Slide | Slides | Pacing |
|------|------|-----------|-------|-------|------------|------------|-----------|---------|-----------|--------|--------|

Sort by retention (highest first). Flag any reel with active paid promotion — its reach and retention numbers are a blend of organic and paid traffic. This table is the foundation for hypothesis formation.

Step 5: Form a testable hypothesis

Based on the patterns in the data, form ONE specific, testable hypothesis for the next reel. Format:

Hypothesis: [If we do X], the new reel will achieve [specific metric target]. Based on: [which data points from the performance table support this]. Test: [what the new reel will do differently to test this]. Success criteria: retention > Y%, or saves > Z, or reach > W. Failure criteria: retention < A% indicates the hypothesis is wrong.

Example hypotheses (based on our Feb 2026 baseline data):

• "If we use an identity/scenario hook with neutral valence and keep the first slide under 3s, the reel will achieve >50% retention" (based on Attention Residue at 79% vs others at 6-16%)
• "If we increase slide count to 23+ and tighten pacing to <3.5s average, the reel will retain above 40%" (based on Attention Residue having the fastest pacing)
• "If we use a factoid hook but keep first slide under 2s and pacing under 3s, we can rescue the factoid format to >30% retention" (testing whether pacing alone can fix the factoid hook problem)

Step 6: Present the analysis

Output the performance table and hypothesis to the user BEFORE proceeding to concept selection. The user should see what the data says and what experiment we're running. This is informational only — don't wait for approval to continue.

Step 7: Log the experiment

After the reel is published, update the reel's performance.md with:

• The hypothesis being tested
• The content attributes (hook type, valence, first slide duration, pacing, slide count)
• Initial metrics (pull 48h after posting)
• Verdict: hypothesis confirmed / rejected / inconclusive (pull 7 days after posting)

Baseline data (Feb 2026)

Reference data from prior analysis. Update this section as new reels are published and analyzed.

| Reel | Date | Retention | Reach | Saves | Paid | Hook Type | Valence | 1st Slide | Slides | Avg Pacing | |------|------|-----------|-------|-------|------|-----------|---------|-----------|--------|------------| | Attention Residue | Feb 27 | 79% | 74 | 1 | ACTIVE $5/day (since Mar 1) | identity/scenario | neutral | 2.56s | 23 | 3.4s | | Mere Exposure | Feb 21 | 16% | 103 | 0 | $4.77 spent (paused Mar 1) | factoid | negative | 2.56s | 20 | ~3.1s | | Zeigarnik Effect | Feb 28 | 13% | 124 | 0 | $0 organic only | factoid/historical | neutral | 5.68s | 18 | 3.7s | | Affect Labeling | Feb 22 | 10% | 58 | 0 | $0 organic only | factoid | neutral | 4.24s | 20 | ~3.9s | | Rumination | Feb 23 | 6% | 36 | 0 | $0 organic only | identity/scenario | negative | 2.88s | 20 | 4.0s |

Patterns identified:

1. Identity/scenario hooks with neutral valence dominate. The only reel above 16% retention uses "You sit down to work, everything's quiet..." (specific, experiential, neutral). Negative-valence identity hooks ("You said one thing wrong...") perform worst.
2. First slide duration matters. The 79% retention reel has a 2.56s first slide. The 13% retention reel has a 5.68s first slide. Keep first slide under 3 seconds.
3. More slides = better retention. 23 slides (3.4s pacing) >> 18-20 slides (3.7-4.0s pacing). Faster visual changes maintain attention.
4. Code is identical across all reels. Same Slide.tsx, CaptionOverlay.tsx, animations. Performance differences are entirely content-driven: hook, valence, pacing.
5. Reach and retention are uncorrelated. Affect Labeling got 1,041 reach with only 10% retention. Reach is distribution; retention is content quality. Optimize retention first.

Phase 1: Concept Selection (→ user approves concept)

The user may invoke this skill in three ways:

• With a specific TikTok concept to remix: User names a TikTok content folder to adapt for Instagram.
• Without a target: Claude identifies un-remixed TikTok concepts and presents options.
• New concept from scratch: User requests original content not based on an existing TikTok.

1. Dedup check — Read ALL content/instagram-reels/*/brief.md to see what's already been remixed. Read ALL content/tiktok/*/brief.md to see available source concepts.
2. Present un-remixed concepts to the user (or accept their direct choice). Wait for approval.

Phase 2: Script & Caption (→ user approves script)

3. Read the source TikTok brief.md to understand the concept, study, and original script.

4. Write a new Instagram script — not a copy of the TikTok script:

   • Shaped by the Phase 0 hypothesis. The hook type, emotional valence, pacing, and first slide duration should all be intentional choices informed by the performance analysis. If the hypothesis says "identity hooks with neutral valence," don't write a factoid hook.
   • Longer: 45-90 seconds (vs TikTok's 30-45s) — Instagram audiences tolerate more depth
   • Deeper: Expand on the psychology, add a second example or implication
   • Same hook-first structure, but the middle section goes further
   • Same tone (dry, restrained, trust the viewer — read docs/writing-style-reference.md)
   • Same voiceover speed target (1.25x)
   • Word count: 110-225 words (at ~2.5 words/sec after 1.25x speedup)
   • CTA rotation: See CTA Rotation Strategy section below. ~2 out of 5 videos get a soft product mention in the last 2-3 seconds of the voiceover.

5. Write Instagram caption — distinctly different from TikTok captions:

   • Length: 2-3 sentences (vs TikTok's 1 sentence). Expand on the psychological insight.
   • Tone: More reflective and thoughtful. Instagram rewards depth.
   • CTA: Send/share-focused (Instagram's top algorithm signal is DM shares). Examples: "send this to someone who needs to hear it," "share with someone whose brain does this," "send to the friend who can't stop overthinking." Use save CTAs occasionally too, but prioritize sends.
   • First sentence: Must stand alone in the feed preview (Instagram truncates after ~125 chars)

6. Write 3-5 hashtags — topic-categorization style, not search-keyword style:

   • Good: #psychology #selfawareness #mentalhealth #overthinking #emotionalintelligence
   • Avoid: #fyp #viral #reels #explore (vanity tags)

7. Agent review — Before presenting to the user, launch a separate Opus agent to proof the script. Use the Agent tool with model: "opus" and include in the prompt:

   • The full script text
   • The Phase 0 hypothesis and performance data context
   • The writing style reference (docs/writing-style-reference.md)
   • Ask the agent to evaluate:
     1. Hook strength — Does it match the identity/scenario pattern? Is the valence relatable frustration (not shame)?
     2. Scientific accuracy — Is the study described correctly? Are there overclaims? (e.g., ego depletion mechanism stated as fact when it's contested)
     3. Script flow — Any awkward transitions, drag points, or energy dips?
     4. Tone — Flag lines that sound too "content creator-y," preachy, or AI-generated
     5. Retention risk — Points where a viewer would scroll away?
     6. Closing line — Does it land? Is it saveable?
     7. Caption & hashtags — Natural send CTA? Hashtags niche-relevant?
     8. Factual concerns — Replication issues, alternative explanations?
   • Ask for specific, actionable feedback with rewrites for any flagged lines
   • Incorporate the agent's strongest suggestions into the script before presenting to user

8. Present revised script + caption + hashtags to user. Mention key changes from the agent review. Wait for approval.

Phase 3: Asset Generation (automated)

After script approval, run these in sequence:

8. Create content folder: content/instagram-reels/YYYY-MM-DD_HHMM_slug/ and save brief.md.

9. Voiceover: pipenv run python3 scripts/tiktok/voiceover.py <content-folder>

   • Reuses existing script (same Benji voice, same ElevenLabs settings, same 1.25x speedup)

10. Background music: Generate via ElevenLabs music API (POST /v1/music):

    • Prompt: "Gentle, warm lo-fi background music. Soft piano with light reverb, positive and hopeful tone. No build-up or intro — start playing immediately from the first beat like elevator music that could loop forever. Steady, unobtrusive, slightly upbeat but not energetic. No drums, no vocals, no crescendos. Background texture, not a performance."
    • Model: music_v1
    • Duration: music_length_ms should be ~10s longer than voiceover duration (to cover the full video)
    • force_instrumental: true
    • Save to assets/background-music.mp3
    • Copy to videos/public/{slug}-reel-music.mp3

11. Transcription: pipenv run python3 scripts/tiktok/transcribe.py <content-folder>

    • Reuses existing script (Deepgram Nova-3, word timestamps)

12. Generate captions data — Convert the Deepgram transcript.json into a TypeScript file for the Remotion caption overlay:

    • Read assets/transcript.json, extract word-level timestamps
    • Write videos/src/{ConceptName}Reel/captions.ts exporting CAPTIONS: Caption[] (from @remotion/captions)
    • Each entry: { text, startMs, endMs, timestampMs, confidence }
    • CRITICAL: Cross-reference against the original script. Deepgram frequently mishears words (e.g., "blank" → "black", "meal" → "mean"). After generating captions.ts, compare every word against the approved script from brief.md. Fix:
      • Misheard words — replace with the correct word from the script (keep the original timestamps)
      • Missing punctuation — add periods, commas, question marks to match the script. This matters because buildPhraseGroups() uses punctuation (., ,, !, ?, ;, :) to break word groups. Without punctuation, groups will be too long.
      • Capitalization — fix proper nouns, acronyms (e.g., "8pm" → "8PM")
    • The timestamps from Deepgram are correct even when the words are wrong — keep the timing, fix the text.

13. Plan slides — Use transcript timestamps to plan slides at ~3s each:

    • More slides than TikTok: ~15-25 slides for 45-90s video
    • First slide must be under 3 seconds (target 2.5s). This is the single biggest retention lever.
    • Target pacing from Phase 0 hypothesis (baseline best: 3.4s avg). More slides = faster pacing = better retention.
    • Identify which existing TikTok illustrations can be reused (reference them by path)
    • Plan new illustrations only for the expanded sections
    • Add slide plan to brief.md

14. Write illustrations JSON — Save to assets/illustrations.json (only new illustrations):

    [{"name": "slug-name", "prompt": "Scene description (style prefix added automatically)"}]
    

15. Generate new illustrations: pipenv run python3 scripts/tiktok/illustrations.py <illustrations-json> <output-dir>

    • Only generates illustrations not already available from the TikTok version

16. Prepare assets — Copy to videos/public/ for Remotion:

    • Reused TikTok illustrations from content/tiktok/.../assets/illustrations/
    • New illustrations from content/instagram-reels/.../assets/illustrations/
    • Voiceover as {slug}-reel-voiceover.mp3
    • Background music as {slug}-reel-music.mp3

Phase 4: Composition & Render (automated)

17. Build Remotion composition at videos/src/{ConceptName}Reel/ with 4 files:

    • config.ts — FPS (30), duration frames, slide definitions
    • Slide.tsx — Individual slide component (same as TikTok pattern)
    • CaptionOverlay.tsx — On-screen caption component (see Caption Spec below)
    • captions.ts — Word-level timestamp data from Deepgram
    • index.tsx — Main composition combining slides + voiceover + music + captions
    • Specs: 1080x1920, 30fps, white background, same slide animation as TikTok compositions
    • Register in Root.tsx under <Folder name="Instagram"> section

18. Composition structure (index.tsx):

    • <Audio> for voiceover at volume={1}
    • <Audio> for background music at volume={0.12} (low, behind narration)
    • <Sequence> for each slide synced to voiceover timestamps
    • <CaptionOverlay /> layered on top of everything

19. Render: cd videos && npx remotion render CompositionId out/{slug}-reel.mp4

20. Archive: Copy mp4 to content/instagram-reels/YYYY-MM-DD_HHMM_slug/

Phase 5: User Approval (→ user approves rendered video)

21. Present the rendered video to the user for review. Provide the file path. Do NOT proceed to publishing until the user explicitly approves. If they request changes, iterate on the composition and re-render.

Phase 6: Publish & Deliver (automated, after approval)

22. Upload to Supabase: pipenv run python3 scripts/instagram/upload_to_supabase.py <video-file>

    • Capture the public URL from stdout

23. Post to Instagram: pipenv run python3 scripts/instagram/post_reel.py "<public-url>" "<caption + hashtags>"

    • Capture the media ID and permalink from stdout

24. Update brief.md with media ID, permalink, and publish timestamp.

25. Delete from Supabase — Clean up after confirmed publishing:

    pipenv run python3 -c "import sys; sys.path.insert(0,'.'); from scripts.instagram.upload_to_supabase import delete_video; delete_video('filename.mp4')"
    

26. Email confirmation — Send to both [email protected] and [email protected] via mcp__google-workspace__send_gmail_message:

    • To: Both recipients (use [email protected] as user_google_email)
    • Subject: {Concept Name} — Instagram Reel Published
    • Body: Caption text + hashtags + Instagram permalink. Plain text, ready to reference.
    • No attachment needed (video is live on Instagram)

CTA Rotation Strategy

Not every video should pitch Clarido — but some must, otherwise the content builds an audience that doesn't know what we sell. Rotate across videos:

Distribution (~out of every 5 videos)

• 3 out of 5: Pure value. No product mention in voiceover. End with the natural script close. Caption has a send/share CTA (Instagram's top algorithm signal is DM shares).
• 2 out of 5: Soft product mention in the last 2-3 seconds of voiceover. The psychology content stays identical — only the closing line changes.

Voiceover CTAs (for the 2-out-of-5 product videos)

Keep it natural and earned — the viewer just learned something real, and the CTA connects the insight to the tool:

• "That's why we built Clarido. Link in bio if this is you."
• "We built an app for brains like this."
• "That's what Clarido does — link in bio."

Never make the CTA the focus of the video. It's a 2-3 second tag at the end, not a pitch.

Caption CTAs (for all videos)

Instagram's algorithm heavily weights DM shares/sends. Every caption should include a send-oriented CTA:

• "Send this to someone who needs to hear it"
• "Share with someone whose brain does this"
• "Send to the friend who can't stop overthinking"

Use save CTAs occasionally too ("save this for your next spiral"), but prioritize sends. Vary the CTA each video — don't repeat the same one back-to-back.

On-Screen Caption Spec

Instagram does NOT auto-generate on-screen captions for Reels uploaded via the API (only closed captions for accessibility). On-screen captions are critical for sound-off browsing, so we bake them into the video.

Style (matches TikTok native caption look)

• White uppercase bold text with thick black stroke outline (8-direction text-shadow)
• Active word: dark red background pill (#B91C1C), rounded corners (borderRadius: 5)
• All words always have identical padding (0px 4px) — only backgroundColor changes between transparent and #B91C1C. This prevents layout shift.
• Single line only — flexWrap: "nowrap", whiteSpace: "nowrap"
• Positioned near bottom — paddingBottom: 300 (above Instagram UI controls)
• Font: 58px, weight 900, system-ui

Word Grouping

Groups words into natural phrases using:

• Max 4 words per group — keeps everything on one line
• Max 20 characters per group — prevents overflow when long words (e.g., "AUSTRALIAN GOVERNMENT APPROVED") would exceed 1080px at 58px uppercase bold. The character check fires before the word count check: if adding the next word would push total characters past 20, break the group even if it has fewer than 4 words.
• Speech pause breaks — new group if gap between words > 250ms
• Punctuation breaks — new group after ., ,, !, ?, ;, : (if group has ≥ 2 words)

Implementation

• CaptionOverlay.tsx — Self-contained component, imports captions.ts
• captions.ts — Generated from Deepgram transcript, exports Caption[] from @remotion/captions
• Do NOT use createTikTokStyleCaptions from @remotion/captions — it merges too many words into single pages with continuous speech. Use the custom buildPhraseGroups() function instead.
• Reference implementation: videos/src/PlanningFallacyReel/CaptionOverlay.tsx

Text Shadow (stroke)

"-2px -2px 0 #000, 2px -2px 0 #000, -2px 2px 0 #000, 2px 2px 0 #000, -3px 0 0 #000, 3px 0 0 #000, 0 -3px 0 #000, 0 3px 0 #000"

Applied to ALL words at ALL times (including when the red background is active).

Background Music Spec

• Source: ElevenLabs Music API (POST /v1/music, model music_v1)
• Style: Minimal, contemplative lo-fi ambient. Soft piano, gentle reverb, no drums, no vocals.
• Duration: Voiceover duration + ~10s buffer
• Mix level: volume={0.12} in Remotion — barely audible, just adds atmosphere behind narration
• force_instrumental: true — always

Helper Scripts

| Script | Purpose | Input | Output | |--------|---------|-------|--------| | scripts/tiktok/voiceover.py | ElevenLabs TTS + 1.25x speedup | Content folder (reads brief.md) | assets/voiceover-raw.mp3, assets/voiceover.mp3 | | scripts/tiktok/transcribe.py | Deepgram Nova-3 word timestamps | Content folder (reads voiceover.mp3) | assets/transcript.json + printed table | | scripts/tiktok/illustrations.py | OpenAI gpt-image-1.5 with style refs | JSON config + output dir | Portrait PNGs in output dir | | scripts/tiktok/prepare_assets.py | Copy assets to Remotion public/ | Content folder | Files in videos/public/ | | scripts/instagram/upload_to_supabase.py | Upload video to Supabase Storage | Video file path | Public URL (stdout) | | scripts/instagram/post_reel.py | Publish Reel via Instagram API | Public video URL + caption | Media ID + permalink (stdout) |

Folder Structure

content/instagram-reels/YYYY-MM-DD_HHMM_slug/
├── brief.md                    # Concept, script, caption, hashtags, slide plan, source ref, media ID
├── assets/
│   ├── illustrations/          # New illustrations only (reused ones referenced from TikTok folder)
│   ├── illustrations.json      # Illustration specs for new illustrations
│   ├── background-music.mp3    # ElevenLabs generated ambient music
│   ├── voiceover-raw.mp3
│   ├── voiceover.mp3
│   └── transcript.json
├── slug-reel.mp4               # Final rendered video
└── performance.md              # Experiment tracking + analytics (see template below)

Remotion Composition Structure

videos/src/{ConceptName}Reel/
├── config.ts                   # FPS, duration, slide definitions
├── Slide.tsx                   # Slide component (illustration + fade/zoom)
├── CaptionOverlay.tsx          # On-screen captions (word-by-word highlight)
├── captions.ts                 # Word timestamps from Deepgram (Caption[])
└── index.tsx                   # Main composition (slides + audio + music + captions)

Performance.md Template

Every reel's performance.md should follow this format for experiment tracking:

# Performance — {Reel Name}

## Experiment

**Hypothesis**: {What we're testing}
**Based on**: {Data points from Phase 0 analysis}
**Success criteria**: {Specific metric targets}
**Failure criteria**: {What would disprove the hypothesis}

## Content Attributes

| Attribute | Value |
|-----------|-------|
| Hook type | {identity/scenario, factoid, contrarian, etc.} |
| Emotional valence | {neutral, negative, positive} |
| First slide duration | {X.Xs} |
| Total slides | {N} |
| Average pacing | {X.Xs} |
| Video duration | {Xs} |
| Has CTA | {yes/no} |

## Metrics (Organic)

| Metric | 48h | 7d | 30d |
|--------|-----|-----|------|
| Retention % | | | |
| Avg watch time | | | |
| Reach | | | |
| Views | | | |
| Likes | | | |
| Saves | | | |
| Shares | | | |
| Comments | | | |
| New followers | | | |

## Paid Promotion (if applicable)

| Metric | Value |
|--------|-------|
| Campaign name | {name or "N/A — not promoted"} |
| Daily budget | |
| Total spend | |
| Paid reach | |
| Paid impressions | |
| ThruPlays | |
| Cost per ThruPlay | |
| Video watch 25%/50%/75%/100% | |

## Verdict

{After 7 days: confirmed / rejected / inconclusive}
{Brief explanation of what the data shows and what to test next}

Critical Details (common mistakes)

• This is NOT a cross-post. Write a new, longer script — don't copy the TikTok script verbatim.
• Reuse illustrations where possible. The TikTok version already has illustrations — reference them directly. Only generate new ones for expanded sections.
• DO NOT publish without user approval. Always show the rendered video and wait for explicit "go".
• Bake captions into the video. Instagram API does not support on-screen auto-captions. Without baked-in captions, sound-off viewers scroll past.
• Do NOT use createTikTokStyleCaptions — it produces giant pages with continuous speech. Use custom buildPhraseGroups().
• No layout shift in captions. Every word must have identical padding/borderRadius at all times. Only toggle backgroundColor.
• Single-line captions only. Use flexWrap: "nowrap", max 4 words per group, AND max 20 characters per group. The character limit prevents long words (like "AUSTRALIAN GOVERNMENT") from overflowing 1080px. Both limits must be in buildPhraseGroups().
• Background music is required. Generate via ElevenLabs, mix at volume={0.12}.
• Image size: Must be 1024x1536 (portrait), NOT 1024x1024
• Audio import: Use <Audio> from @remotion/media, NOT from core remotion
• ElevenLabs stability: Only 0.0, 0.5, or 1.0 — no in-between values
• Overflow: Set overflow: "visible" on slide container to prevent zoom clipping
• Always run the Opus agent review before presenting the script to the user. The agent catches overclaims, tone issues, and weak closers that are easy to miss.
• Always cross-reference captions against the script. Deepgram mishears words regularly. Compare every word in captions.ts against the approved script and fix misheard words + missing punctuation before rendering.
• Always run Phase 0 first. Pull metrics, analyze, form a hypothesis. Every new reel is an experiment. Skip Phase 0 only if the user explicitly says to.
• Log the experiment. After publishing, create performance.md with the hypothesis and content attributes. Pull 48h metrics and 7-day metrics to validate.
• Update baseline data. After each reel gets 7-day metrics, update the baseline table in Phase 0 of this skill file so future runs have the latest data.
• Run end-to-end: Generate all assets, render, get approval, publish, email — don't stop partway

Key Files

• Writing style reference: docs/writing-style-reference.md
• TikTok method doc: docs/tiktok-psych-video-method.md (parent pattern)
• Brand reference images: assets/illustrations/overwhelmed-filing-cabinet.png, floating-yellow-balloon.png, planting-yellow-seedling.png
• Example Instagram Reel composition: videos/src/MereExposureEffectReel/ (config.ts, Slide.tsx, CaptionOverlay.tsx, captions.ts, index.tsx)
• Example Instagram Reel brief: content/instagram-reels/2026-02-21_2020_mere-exposure-effect/brief.md
• Example TikTok composition: videos/src/ParadoxOfChoiceTikTok/ (config.ts, Slide.tsx, index.tsx)