Clip Editor Skill — Faceless TikTok Video Production

Trigger: "edit clip", "improve video", "clip quality", "video editing", "capcut", "opusclip", "batch clips", "clip pipeline"

Tool Chain

Production Pipeline

Step 0: Scanner Check

Check overnight scanner results before creating any clips. Only create clips for campaigns that scored well in the automated scan. Review automations/overnight-pipeline/data/ for the latest scan output and skip any campaigns flagged as underperforming.

Step 1: Source Content

• Pull assets from campaign Google Drive link or provided files
• Identify long-form source clips (interviews, podcasts, product demos, screen recordings)
• Organize into ~/Desktop/clips/{campaign-name}/raw/

Step 2: OpusClip — Auto-Clip

• Upload long-form video to OpusClip
• Let virality scoring rank the best moments
• Download top 3-5 clips per source video
• Save to ~/Desktop/clips/{campaign-name}/opusclip-output/
• Review each clip: does it have a natural hook? Does it stand alone without context?

Step 3: CapCut — Polish

• Import OpusClip output into CapCut
• Apply the appropriate template (see CapCut Templates below)
• Add captions (auto-generate, then clean up timing and accuracy)
• Add brand logo overlay (see Logo Placement rules)
• Add #ad disclosure overlay in first 3 seconds
• Trim dead space, tighten pacing
• Export as 1080x1920

Step 4: Realify — Anti-AI Detection Pass (MANDATORY)

Every AI-generated or AI-edited clip MUST go through realify-video.py before export. This is non-negotiable. Clean AI video gets flagged by viewers and suppressed by algorithms.

# Tool location
/Users/tori/Documents/Repos/CHI/face-swap/realify-video.py

# Default (best for sponsored clips)
python3 /Users/tori/Documents/Repos/CHI/face-swap/realify-video.py input.mp4

# Lighter touch (higher quality, less degradation)
python3 /Users/tori/Documents/Repos/CHI/face-swap/realify-video.py input.mp4 -g 1.5 -c 24 -v -25

# Maximum "reposted from Telegram" look
python3 /Users/tori/Documents/Repos/CHI/face-swap/realify-video.py input.mp4 -g 4.0 -c 35 -v -16

# Custom ambient noise (coffee shop, street, room tone)
python3 /Users/tori/Documents/Repos/CHI/face-swap/realify-video.py input.mp4 -a ambient.wav

What it does (4 KNOX tweaks):

1. Film grain (2.5% default) — breaks up the too-clean AI render look
2. Ambient noise — adds faint pink noise under audio so AI silence doesn't give it away
3. Smart 1080p scaling — auto-detects portrait/landscape, pads if needed
4. Telegram-style compression (CRF 30) — adds natural reupload artifacts

Flags: --grain/-g (0-10), --noise-volume/-v (dB), --crf/-c (0-51), --ambient-file/-a, --dry-run

When to use which preset:

Step 5: FFmpeg — Additional Processing (if needed)

For clips that need extra FFmpeg work beyond realify (logo overlay, disclosure, trimming):

# Standard vertical render (1080x1920, H.264, AAC, optimized)
ffmpeg -i input.mp4 \
  -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:black" \
  -c:v libx264 -preset slow -crf 22 \
  -c:a aac -b:a 128k \
  -movflags +faststart \
  output.mp4

Note: If using both FFmpeg and realify, run FFmpeg FIRST (logo, disclosure, trimming), then realify LAST. Realify should always be the final step so compression artifacts sit on top of everything.

Step 6: Quality Check

Run through this checklist before export:

• Resolution is 1080x1920 (9:16 vertical)
• Duration is 15-35 seconds
• Hook grabs attention in first 1-2 seconds
• Brand logo visible and non-intrusive
• #ad disclosure visible in first 3 seconds AND in caption text
• Captions are clean, readable, properly timed
• No dead space or awkward pauses
• Audio levels consistent (no clipping, no whisper sections)
• No platform UI elements blocked by overlays
• File size under 50MB
• Realify pass completed — grain visible, no dead silence, compression artifacts present

Step 7: Export and Post

• Rename to {campaign}-{YYYYMMDD}-{clip_number}.mp4
• Upload to campaign delivery folder
• Target 3-5 posts per week per campaign
• Log clip details for weekly review

Quality Standards

Sponsored disclosure: Every clip is a paid sponsorship. #ad overlay in first 3 seconds is MANDATORY, not optional. This is an FTC requirement, not a style choice. Missing disclosure on even one clip risks the entire account. Treat it as a hard blocker in QC — no disclosure = no publish.

Logo Placement Safe Zones

Avoid these areas where platform UI overlaps:

• Top 15%: Profile icons, live indicators
• Bottom 20%: Caption area, action buttons
• Right 10%: Like/comment/share buttons (TikTok, Reels)
• Best placement: Lower-left corner, 5-8% from edges, 60-80% opacity

Boxed Format (for 16:9 talking-head source)

When the source is horizontal (16:9), use blurred pillarbox:

ffmpeg -i input_16x9.mp4 \
  -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,boxblur=20:5[bg];[0:v]scale=1080:-2:force_original_aspect_ratio=decrease[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2" \
  -c:v libx264 -preset slow -crf 22 \
  -c:a aac -b:a 128k \
  -movflags +faststart \
  output_vertical.mp4

FFmpeg Command Reference

Add Logo Overlay

# Logo in lower-left safe zone, 70% opacity
ffmpeg -i input.mp4 -i logo.png \
  -filter_complex "[1:v]format=rgba,colorchannelmixer=aa=0.7,scale=120:-1[logo];[0:v][logo]overlay=54:H-h-384" \
  -c:v libx264 -preset slow -crf 22 \
  -c:a copy \
  output_with_logo.mp4

Add #ad Disclosure Overlay (first 3 seconds)

ffmpeg -i input.mp4 \
  -vf "drawtext=text='#ad':fontsize=36:fontcolor=white:borderw=2:bordercolor=black:x=54:y=108:enable='lt(t,3)'" \
  -c:v libx264 -preset slow -crf 22 \
  -c:a copy \
  output_with_ad.mp4

Combined: Logo + Disclosure

ffmpeg -i input.mp4 -i logo.png \
  -filter_complex "[1:v]format=rgba,colorchannelmixer=aa=0.7,scale=120:-1[logo];[0:v][logo]overlay=54:H-h-384[v1];[v1]drawtext=text='#ad':fontsize=36:fontcolor=white:borderw=2:bordercolor=black:x=54:y=108:enable='lt(t,3)'" \
  -c:v libx264 -preset slow -crf 22 \
  -c:a copy \
  output_final.mp4

Generate Thumbnail

# Grab frame at 1 second (usually the hook moment)
ffmpeg -i input.mp4 -ss 00:00:01 -vframes 1 -q:v 2 thumbnail.jpg

Get Video Info

ffprobe -v quiet -print_format json -show_format -show_streams input.mp4

Trim Clip

ffmpeg -i input.mp4 -ss 00:00:02 -to 00:00:30 -c copy trimmed.mp4

Concatenate Multiple Clips

# Create file list
echo "file 'clip1.mp4'" > list.txt
echo "file 'clip2.mp4'" >> list.txt
echo "file 'clip3.mp4'" >> list.txt

ffmpeg -f concat -safe 0 -i list.txt -c copy merged.mp4

Normalize Audio Levels

ffmpeg -i input.mp4 -af loudnorm=I=-14:TP=-1:LRA=11 -c:v copy output_normalized.mp4

Batch Processing

Process All Clips in a Directory (Weekly Batch)

#!/bin/bash
# Weekly batch processing — run once per batch (3-5 clips per week)
# Pipeline: FFmpeg (logo + disclosure) → realify (grain + noise + compression)
CAMPAIGN="$1"
DATE=$(date +%Y%m%d)
INPUT_DIR="$HOME/Desktop/clips/${CAMPAIGN}/capcut-output"
STAGE_DIR="$HOME/Desktop/clips/${CAMPAIGN}/staged"
OUTPUT_DIR="$HOME/Desktop/clips/${CAMPAIGN}/final"
LOGO="$HOME/Desktop/clips/${CAMPAIGN}/logo.png"
REALIFY="/Users/tori/Documents/Repos/CHI/face-swap/realify-video.py"
COUNT=1

mkdir -p "$STAGE_DIR" "$OUTPUT_DIR"

for f in "$INPUT_DIR"/*.mp4; do
  STAGED="${STAGE_DIR}/${CAMPAIGN}-${DATE}-$(printf '%02d' $COUNT)_staged.mp4"
  OUTPUT="${OUTPUT_DIR}/${CAMPAIGN}-${DATE}-$(printf '%02d' $COUNT).mp4"

  # Step 1: FFmpeg — logo overlay + #ad disclosure
  ffmpeg -y -i "$f" -i "$LOGO" \
    -filter_complex "[1:v]format=rgba,colorchannelmixer=aa=0.7,scale=120:-1[logo];[0:v]scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:black[scaled];[scaled][logo]overlay=54:H-h-384[v1];[v1]drawtext=text='#ad':fontsize=36:fontcolor=white:borderw=2:bordercolor=black:x=54:y=108:enable='lt(t,3)'" \
    -c:v libx264 -preset slow -crf 20 \
    -c:a aac -b:a 128k \
    -movflags +faststart \
    "$STAGED"

  # Step 2: Realify — grain + ambient noise + Telegram compression (MANDATORY)
  python3 "$REALIFY" "$STAGED" "$OUTPUT"

  COUNT=$((COUNT + 1))
done

# Clean up staging dir
rm -rf "$STAGE_DIR"

echo "Processed $((COUNT - 1)) clips for weekly batch to $OUTPUT_DIR"

Batch Thumbnail Generation

for f in final/*.mp4; do
  ffmpeg -i "$f" -ss 00:00:01 -vframes 1 -q:v 2 "${f%.mp4}_thumb.jpg"
done

Naming Convention

{campaign}-{YYYYMMDD}-{clip_number}.mp4

Examples:

• acme-widgets-20260302-01.mp4
• acme-widgets-20260302-02.mp4
• skincare-launch-20260302-01.mp4

CapCut Templates

Maintain these project templates in CapCut. Save each as a reusable template.

1. Product Showcase

• Clean, minimal aesthetic
• Product hero shots with slow zoom/pan
• Solid or gradient background
• Short text callouts (feature, price, CTA)
• Music: ambient/electronic, low energy
• Transitions: dissolve, slide

2. Compilation / Montage

• Fast cuts synced to beat drops
• 0.5-1.5 sec per clip
• Music-driven pacing (pick music first, cut to it)
• Minimal text — let the visuals carry
• Transitions: hard cut on beat, whip pan, zoom
• Energy ramps up through the clip

3. Text Story

• Text overlay on background footage (stock or campaign B-roll)
• Large, readable font (CapCut default bold works)
• Reveal text line-by-line with timing
• Background footage: slow motion, abstract, or loosely related
• Music: emotional/ambient underscore
• CTA at the end as final text card

4. Tutorial / How-To

• Screen recording + voiceover (or text caption walkthrough)
• Numbered steps as text overlays
• Zoom in on key UI elements
• Cursor highlighting or annotation
• Music: minimal, stays out of the way
• End card with CTA or link

5. Reaction / Commentary

• Source clip plays with text reaction overlays
• "POV:" or "When..." style opener
• Emoji reactions or text pops at key moments
• Music: trending audio if applicable
• Keep source audio if it adds value, mute if not

Weekly Improvement Cycle

Every week (ideally Monday), review the previous week's clips:

Review Process

1. Pull view/engagement numbers for all posted clips
2. Rank by performance (views, likes, shares, comments, watch time)
3. For the top 3 performers, note:
   • What was the hook? (first 1-2 sec)
   • Pacing: fast or slow?
   • Did it use trending audio?
   • Caption style (word-by-word vs sentence)?
   • Visual style (which template)?
4. For the bottom 3, note what fell flat
5. Update the approach for next week

Learnings Log

Store editing learnings in /Users/tori/Documents/Repos/CHI/clip-editor-learnings.json:

{
  "last_updated": "2026-03-02",
  "learnings": [
    {
      "date": "2026-03-02",
      "insight": "Word-by-word captions outperform sentence captions by 2x on watch time",
      "source": "campaign-x clips week of 2/24",
      "action": "Switch all templates to word-by-word caption style"
    }
  ],
  "best_performing_hooks": [],
  "caption_style_winner": "",
  "avg_clip_duration_sweet_spot": "",
  "top_templates": []
}

Metrics to Track

• Average watch time (% of clip watched)
• View-to-like ratio
• Share count (strongest signal of viral potential)
• Comment sentiment
• Which hook type performs best (question, shock, visual, text)

Face Swap (when needed)

Use Deep-Live-Cam for face replacement:

cd ~/Documents/Repos/Deep-Live-Cam
python run.py --source face.jpg --target input.mp4 --output output.mp4

Or use the CHI face-swap scripts:

python /Users/tori/Documents/Repos/CHI/face-swap/swap.py --source face.jpg --target input.mp4 --output output.mp4
python /Users/tori/Documents/Repos/CHI/face-swap/process_video.py --input raw.mp4 --output processed.mp4

Quick Reference Checklist

When someone says "edit clip" or "make a clip", run through this:

1. What campaign is this for?
2. Did this campaign pass the overnight scanner check? (Step 0)
3. Where is the source content? (Drive link, local file, URL)
4. Which template type? (product, compilation, text story, tutorial, reaction)
5. Is there a brand logo to overlay?
6. #ad disclosure is MANDATORY on every clip (not a question — always yes)
7. Any specific audio/music to use?
8. Target duration?
9. Delivery format and destination?
10. How many clips this week? (target: 3-5 per campaign)

Then execute the pipeline: Scanner Check -> Source -> OpusClip (if long-form) -> CapCut -> FFmpeg (logo/disclosure) -> Realify (MANDATORY) -> QC -> Export.

CRITICAL: realify-video.py is the LAST processing step before upload. Never skip it on AI-generated content.