# 🎬 17 Video Effects with Claude: Ready-to-Use Prompt Guide

**by @fatihturkmen.ai**

The prompts I use to add effects to talking-head videos without opening After Effects, just by describing them to Claude. They are all written for **Claude Opus 5.5 + Claude Code**.

## What you need
- **Claude Code** (desktop app or terminal). Choose **Opus 5.5** as the model.
- A folder on your computer with your vertical video in it: `input.mp4` (1080×1920 is ideal).
- Claude installs the rest (ffmpeg, Python libraries and so on).

> 💡 **How does it work?** Claude processes your video frame by frame: it transcribes your speech (with word timings), extracts a mask that separates you from the background, then adds the effects layer by layer and renders a new .mp4. Your job is only to describe what you want, watch the result and ask for fixes.

## How to use it
1. Open the folder with your video in Claude Code.
2. Paste the **0. Setup** prompt first (only the first time).
3. Then paste the prompt of the effect you want. Fill in the `[SQUARE BRACKET]` parts for your own video.
4. Watch the video it renders and fix anything you don't like with the "Fix prompts".


---

# 0. Setup: the video effects toolkit

Paste this the first time. Claude sets up the shared tools every later effect uses.

```
Set up a video effects toolkit in this folder that we will use to add effects to my talking-head videos.
Source video: input.mp4 (vertical, 1080x1920).

What to set up:
1. Check whether ffmpeg is installed and install it if not. Create a Python virtual environment (venv).
2. Transcription: transcribe the video word by word with timestamps using faster-whisper
   (language: [LANGUAGE, e.g. English]). Save the result as words.json: [{word, start, end}].
3. Person mask: with Robust Video Matting, extract an alpha mask for every frame that separates
   the person from the background (if it doesn't work, use MediaPipe Selfie Segmentation).
   Save the masks as PNGs in the masks/ folder. Soften the edges by 2-3 px and apply
   temporal smoothing to reduce flicker between frames.
4. Write a shared helper module called fx.py:
   - read / write frames (through an ffmpeg pipe, keeping the original audio)
   - easing functions (easeOutCubic, easeInOutQuint, easeOutBack, spring)
   - "foreground / background" layering: use the mask to put a graphic BEHIND the person
     (the graphic goes on the background, the person on top)
   - motion blur (with sub-frame sampling on moving layers)
   - finding the frame number from a word time: frame_at("word")
   - rendering graphics designed in HTML/CSS to transparent PNGs with Playwright
5. Caption style: bold sans-serif (use Inter Black / Gilroy if available),
   white text, accent words in [ACCENT COLOR, e.g. #FFE14D], with a word-by-word
   pop animation (scale 0.8→1.05→1, 180 ms).

Output settings: 1080x1920, the source video's fps, H.264, CRF 18, audio AAC 192k.
We will write each effect as a separate Python file (in the effects/ folder).

When the setup is done, run a short test: add only captions to the first 3 seconds of the video,
export it as test.mp4 and summarize what is ready.
```

---

# Shared style block (optional)

If you want all your videos to look like the same brand, add this to the end of every effect prompt:

```
Style rules:
- Color palette: [MAIN COLOR], [ACCENT COLOR], [LIGHT COLOR], [DARK COLOR]
- Font: headings in [FONT] Black/ExtraBold, accent words in [FONT] Italic
- Nothing moves linearly: entrances use easeOutBack (a slight overshoot),
  exits use easeInCubic. When there are several elements, they enter staggered 60-80 ms apart.
- Fast moves get motion blur.
- Graphics never cover my face; keep the area of my face clear.
```

## Example: the look of the previews (Signature)

For the burgundy/cream look of the preview videos, fill in the block like this:

```
Style rules:
- Color palette: #6B0B0C (burgundy background), #FF6B3D (accent), #FFF8CA (cream), #2D120D (dark)
- Font: headings in Urbanist Black/ExtraBold, accent words in Instrument Serif Italic
- Nothing moves linearly: entrances use easeOutBack (a slight overshoot),
  exits use easeInCubic. When there are several elements, they enter staggered 60-80 ms apart.
- Fast moves get motion blur.
- Graphics never cover my face; keep the area of my face clear.
```

---

# 1. Orbit

**What it does:** Screenshots, video cards or logos orbit around you in 3D. The cards don't cover you when they pass behind you, and they overlap you when they pass in front.
**When to use it:** When you talk about several things ("I did this, and this, and that...").

```
effects/orbit.py: add an "Orbit" effect between [START S] and [END S].

- Turn the [5] images in the assets/orbit/ folder into cards with rounded corners (24 px),
  a thin white border and a soft shadow.
- The cards orbit on a tilted ellipse centered at my chest height
  (horizontal radius 42% of the screen, vertical radius 10%, the orbit tilted 12°).
- A real 3D feel: cards at the back of the orbit are at 70% size, slightly blurred and
  BEHIND THE PERSON MASK; cards at the front are at 100% size, sharp and IN FRONT of the person.
- One full turn takes 6 s. The cards enter the orbit by opening out from the center in 0.4 s (easeOutBack).
- When "[ACCENT WORD]" is spoken, a bright [ACCENT COLOR] serif italic word appears
  in the middle, with a small ✦ star sparkle next to it.

Render a 2-second preview first; if I approve it, render the whole thing.
```

**Tip:** Put your own screenshots on the cards (from your earlier videos, app screens). Real content always looks more convincing.

---

# 2. Couch Wall

**What it does:** The wall behind you turns into a grid of thumbnails from your earlier videos. You stay in front, and every card shows its view count in the corner.
**When to use it:** Social-proof moments ("these videos got millions of views").

```
effects/couch_wall.py: add a "Couch Wall" effect between [START S] and [END S].

- Turn the background into a grid of 3 columns x 4 rows with the images in the assets/thumbs/ folder
  (6 px between cards, 10 px rounded corners).
- Put a small "▷ [VIEWS]" label in the bottom-left corner of every card
  (values: [1.07M, 534K, 133K, 5,488 ...]).
- Add small white title strips to the top of some cards (like a video title).
- Use the person mask to keep me IN FRONT of the grid; the original background disappears completely.
- Entrance: the cards open from the center outward, staggered (40 ms apart), scale 0→1.
- A two-line title in the lower third of the screen:
  small line "[TOP LINE]", large and very bold line "[MAIN WORD]" (white, with a light shadow).
- The grid zooms in very slowly (4% over 3 s, Ken Burns).
```

---

# 3. UI World

**What it does:** The top half of the screen becomes a Claude chat interface. Clips are dragged in and a command is typed; in the bottom half you keep talking.
**When to use it:** "Here's how I do it" moments, to show the process.

```
effects/ui_world.py: add a "UI World" effect between [START S] and [END S].

- Make the background cream (#F5F1E8). My video sits in the bottom 55% of the screen,
  with a soft fade at its top (feather 80 px).
- In the top part, design a Claude interface in HTML:
  a small orange ✳ logo + the word "Claude" in the middle, and under it a white,
  rounded message box.
- Animation order:
  1) 5 small video thumbnails slide into the message box from left to right
     (80 ms apart each), and a yellow "RAW CLIPS" label appears at their top right.
  2) "[COMMAND, e.g. /video-edit]" is typed into the box letter by letter (45 ms per letter), with a blinking cursor.
  3) A click effect on the orange send button at the bottom right (scale 0.9→1).
- My captions in large, bold white letters over the video;
  when [ACCENT WORD] comes, its letters appear behind a mask that opens from left to right.
- The interface enters by sliding down 30 px from above, with a fade-in (easeOutCubic, 400 ms).
```

---

# 4. Frame Break

**What it does:** The video first shrinks into an Instagram Reels frame (with like/comment icons). Then you break out of that frame: your hand or head crosses its edge.
**When to use it:** To grab attention at the start of a video, or in "Claude edited this video too" moments.

```
effects/frame_break.py: add a "Frame Break" effect between [START S] and [END S].

- Background: dark green-black (#1A1F1A) with a vignette that darkens toward the edges.
- The video shrinks from 100% to 62% in 0.6 s (easeInOutQuint) and turns into an Instagram
  Reels interface: like/comment/share icons on the right, at the bottom
  "@[USERNAME]" + a "Follow" button and a small caption
  "[CAPTION, e.g. claude edited this whole reel]". Corners rounded 28 px.
- FRAME BREAK: using the person mask, draw the parts of me that go OUTSIDE the frame
  (my head, my hands) on top of the frame. The frame cuts the background, but not me.
  To do this, draw the video inside the frame, and outside the frame only the masked me.
- The frame itself sways slightly (±1.5°) and has a shadow.
- At [EXIT S] the frame grows back to full screen.
```

---

# 5. Digital Zoom

**What it does:** On important words the video punches in sharply toward your face, and the caption appears big and in two colors.
**When to use it:** In every video. The simplest effect, and the most effective.

```
effects/digital_zoom.py: add a "Digital Zoom" effect to the whole video.

- Read words.json and pick the [6-8] most important words for the meaning of the video yourself
  (or use these words: [WORD 1, WORD 2, ...]).
- On every accent word, zoom in toward my face (find the face center with MediaPipe Face
  Detection):
  - scale 1.00 → 1.18 in 120 ms, easeOutCubic (punch-in)
  - when the word ends, ease back to 1.06 within 400 ms
  - alternate a close (1.18) and a medium (1.10) zoom so it doesn't repeat
- A light 2-frame motion blur during the zoom.
- Captions: in the lower third, in word groups (2-3 words). The accent word is split
  into two lines: top line white, bottom line [ACCENT COLOR], very bold,
  with a light outer shadow. Words pop in with scale 0.85→1.04→1.
- The image must not get blurry while zooming: scale the source frame with high quality
  (Lanczos).
```

---

# 6. Phone Mockup

**What it does:** A slightly tilted iPhone appears next to your head. An app interface runs live on its screen.
**When to use it:** When you talk about an app, a tool or a result.

```
effects/phone_mockup.py: add a "Phone Mockup" effect between [START S] and [END S].

- Design a dark-theme phone app screen in HTML:
  the title "[APP NAME]", under it a suggestion card
  ("[SUGGESTION TEXT, e.g. Pause ad 3, move its budget to ad 1]"),
  small chart icons, and a white "[BUTTON, e.g. Approve]" button.
- Put this screen into a realistic iPhone frame (black bezel, Dynamic Island,
  rounded corners, a thin glare reflection).
- The phone sits in the top-right quarter of the screen, next to my face (without covering it),
  rotated -18° on the Y axis and 6° on the Z axis, with perspective.
- Entrance: it comes in from the bottom right while rotating (spring animation, 600 ms).
  While it stays, it floats very slightly (±6 px, 3 s loop).
- At [TAP S], a tap effect on the button on the screen (a gray circle grows and fades),
  then the card switches to a green "✓ [RESULT TEXT]" state.
- Captions under the video, bold white.
```

---

# 7. Checklist

**What it does:** A semi-transparent, frosted-glass to-do card appears at the top of the screen. Each item is checked off as you say that step.
**When to use it:** Step-by-step moments like "there are 3 things you need to do".

```
effects/checklist.py: add a "Checklist" effect between [START S] and [END S].

- Put a dark, frosted-glass rounded card in the top 30% of the screen (it blurs the background,
  #111 at 70% opacity + a 1 px white border at 10%).
- Card header: top left, small spaced capitals "● [TITLE, e.g. WHAT YOU NEED TO DO]",
  top right a "[n] / [total]" counter.
- Items:
  1. [ITEM 1] → checked when "[TRIGGER WORD 1]" is spoken
  2. [ITEM 2] → "[TRIGGER WORD 2]"
  3. [ITEM 3] → "[TRIGGER WORD 3]"
- Items whose turn hasn't come yet show only as a gray line (a skeleton).
  When an item's turn comes, its text opens from left to right.
- The moment of checking: the empty circle turns into a filled yellow-green (#C8F04A) circle and a ✓ is drawn inside it
  (stroke animation, 250 ms), the card bounces slightly (scale 1.02) and the counter goes up.
- The card slides in from the top and slides back up 1 s after the last item.
```

---

# 8. Headline Wall

**What it does:** Paper notes with headlines about you or your topic stick to the wall behind you, one by one.
**When to use it:** "Everyone is talking about this" moments, or when you describe what's happening.

```
effects/headline_wall.py: add a "Headline Wall" effect between [START S] and [END S].

- Turn these headlines into paper notes:
  "[HEADLINE 1]", "[HEADLINE 2]", "[HEADLINE 3]", "[HEADLINE 4]", "[HEADLINE 5]", "[HEADLINE 6]", "[HEADLINE 7]", "[HEADLINE 8]"
- Give every note a different style: a newspaper clipping (serif headline + small column text),
  a cream sticky note (handwritten italic serif), a white card (a small label + a headline).
  Paper texture, a soft shadow and a random angle of ±8°.
- The notes go on the wall (BEHIND the person mask) and fill the area behind my face
  and body completely, but never cover me.
- Each note "sticks" on 120 ms after the previous one: scale 1.15→1, its angle settles slightly,
  and its shadow tightens as it lands (the feeling of paper touching the wall).
- Overall the image is slightly warm-toned and contrasty.
```

---

# 9. Zoom-Through Cut

**What it does:** Between two cuts the camera dives forward fast. You "fly" into the next shot with a radial blur.
**When to use it:** On shot changes, when the topic changes.

```
effects/zoom_through.py: add a "Zoom-Through Cut" transition at these cut points:
[S 1], [S 2], [S 3]  (or look at words.json and pick suitable places between sentences yourself)

Each transition is 10 frames in total:
- Outgoing shot: in its last 5 frames, a fast zoom from scale 1.0 → 2.2 (easeInExpo),
  a radial motion blur outward from the center (growing in strength), brightness +15%.
- Incoming shot: in its first 5 frames, it opens from scale 0.6 → 1.0 (easeOutExpo),
  and the radial blur fades out.
- The zoom center is my face (with face tracking).
- A light 1-frame white flash (20% opacity) right in the middle of the transition.
- The audio is not cut; the transition is visual only and the sound keeps flowing.
```

---

# 10. Chart Grow

**What it does:** A glowing neon line chart draws itself behind you, rising over days or months. A label appears at the peak.
**When to use it:** When you talk about growth, results or statistics.

```
effects/chart_grow.py: add a "Chart Grow" effect between [START S] and [END S].

- Darken the image by 25% and pull it toward a slightly cool tone (so the chart stands out).
- BEHIND the person mask, place a line chart that covers the top half of the screen:
  - X-axis labels at the top: [M T W T F S S] (thin, white at 70%)
  - Data points: [10, 12, 11, 18, 26, 45, 80] (a sharp rise in the last days)
  - Line: 4 px, neon [ACCENT COLOR, e.g. #E8FF4D], with an outer glow
  - Under it, a semi-transparent fill in the same color that fades out downward
- The line draws from left to right in 1.5 s (easeInOutCubic); a small white dot
  appears on every data point.
- When the line reaches the last point, the point glows, a vertical dashed line drops from it,
  and above it a neon pill label with black text appears: "[LABEL, e.g. SCALE ↗]".
- If the line passes behind my hand, my hand stays in front (with the mask).
```

---

# 11. Pull-Back Reveal

**What it does:** The camera pulls back and reveals that the video you're watching is actually inside an editing app, being edited by Claude.
**When to use it:** "AI edited this video too" moments and meta scenes.

```
effects/pull_back.py: add a "Pull-Back Reveal" effect between [START S] and [END S].

- While the video is full screen, it shrinks to 58% in 0.8 s (easeInOutQuint), and a light cream
  (#F3F0E6) desktop app window appears around it:
  - Window title: three colored dots + "[FILE NAME, e.g. reel-v1.mp4]" + "Assistant" on the right
  - My video plays inside the window
  - Under it a timeline: an audio waveform (generated from the video's real audio),
    a moving playhead, and a "frame counter / total frames" counter on the right
- On the left of the window, a small side panel that overlaps it slightly:
  the title "● Working on [edit]" and steps that get checked in order:
  "Clip transcribed" → "Best take picked" → "3 shots cut" →
  "Captions added" → "[N] frames rendered"
  (each one checked ✓ 0.5 s after the previous; steps not done yet are faded)
- My captions stay inside the window, at the bottom of the video.
- At the end the window grows back to full screen and closes.
```

---

# 12. Green Screen

**What it does:** Your background disappears completely. You stand in front of a colored backdrop and a big app interface.
**When to use it:** When you present a product, a page or an interface.

```
effects/green_screen.py: add a "Green Screen" effect between [START S] and [END S].

- Separate me from the background with the person mask; no green/color spill on the edges,
  keep the hair edges soft.
- New background: a vertical gradient from top to bottom, [COLOR 1, e.g. #6A2CF5] → [COLOR 2, e.g. #3B1FA8],
  with a very light grain.
- In the middle of the background, put a big app screen designed in HTML:
  [SCREEN DESCRIPTION, e.g. a "Focus mode" app: a 49:57 timer at the top and the task
  "Write the sales page", the other tasks locked below it,
  the serif italic text "The rest can wait." in the middle, a message box at the bottom]
- I stand IN FRONT of this screen, in the bottom half (scaled down to about 60%).
- The timer on the screen counts down in real time; "[TEXT]" is typed into the message box letter by letter,
  and the mouse cursor moves to the send button.
- The accent word of the captions appears as a white label on a black background.
- Add a very light rim light to me in the background's color, so I don't look pasted on.
```

---

# 13. Paper Cut

**What it does:** You become a cut-out with a torn paper edge, stuck onto a collage page. Around you: scribbles, tape, ransom-note letters and colored paper scraps.
**When to use it:** When you want a fun, handmade (DIY) feel.

```
effects/paper_cut.py: add a "Paper Cut" effect between [START S] and [END S].

- Background: a light grid, cream notebook paper texture.
- Cut me out with the person mask; add a 14 px white paper edge outside the mask
  and make that edge irregular, like torn paper (an edge distorted with Perlin noise),
  + a light shadow. I should look like a paper cut-out stuck onto the page.
- Collage elements (draw them with HTML/Pillow):
  - Top left, "[NUMBER/WORD, e.g. 100]" in ransom-note style letters
    (each letter a cut paper scrap in a different color, font and slight angle)
  - Behind, torn blue and yellow paper strips with colored pen scribbles on them
  - Small hand-drawn X's, stars, a spiral line, and semi-transparent tape pieces in the corners
- Animation: for a "stop-motion" feel, all collage elements jitter 1-2 px at random
  8 times a second (every 3-4 frames). The elements arrive one by one as if "stuck on"
  (scale 1.2→1 in 2 frames, without easing).
- My cut-out also changes its angle very slightly (±0.5°) 8 times a second.
```

---

# 14. Doodle Boil

**What it does:** A hand-drawn white outline is drawn around your body and keeps "boiling" (jittering) like in line animations. Small doodle icons appear around you.
**When to use it:** In fun, energetic moments. One of the most eye-catching effects.

```
effects/doodle_boil.py: add a "Doodle Boil" effect between [START S] and [END S].

- Extract my outer contour from the person mask (OpenCV findContours) and offset it 12 px outward.
- Draw this contour as a white, hand-drawn pen line:
  - Thickness varying between 4 and 6 px, round caps
  - A small random offset on every point (hand shake)
  - The "BOIL" effect: regenerate the random offsets every 3 frames, so the line
    keeps moving (like "line boil" in 2D animation). In between, the line stays still.
  - The line has a slight chalk/pencil texture (irregular alpha at the edges)
- Entrance: the contour is drawn around me within 0.5 s, starting from the top of my head (stroke reveal).
- White hand-drawn icons appear next to me, following what I say:
  "[WORD 1]" → [ICON 1, e.g. a clapperboard]  ,  "[WORD 2]" → [ICON 2, e.g. a light bulb]
  The icons boil with the same effect and are drawn on as they come in.
- Cool the video colors by 10% and raise the contrast a little, so the white line glows.
```

---

# 15. Vertigo

**What it does:** Hitchcock's famous "dolly zoom": you stay the same size while the background stretches toward you or away from you. A dizzying feeling.
**When to use it:** A surprising fact, a dramatic moment, or a "wait, this is important" moment.

```
effects/vertigo.py: add a "Vertigo" (dolly zoom) effect between [START S] and [END S].

- Separate me and the background with the person mask.
- In the background, fill the hole left by removing me from the surrounding pixels
  (OpenCV inpaint, or temporally from earlier frames).
- During the effect:
  - Background: grows from scale 1.0 → [1.35] (centered on my face), with a light
    perspective distortion at the same time (the edges stretch more, the center less)
  - Me: scale 1.0 → 0.97, so almost unchanged
  - Easing: easeInOutSine, [1.2] s in total
- Add a very light radial blur to the background (stronger at the edges).
- The accent word "[WORD]" appears in the middle at the same time, in large, bold, white letters.
- You can also do it in reverse if you like: the background shrinks (1.35 → 1.0), which feels like "moving away".
```

---

# 16. Cover Story

**What it does:** The video turns into a magazine cover: a huge serif magazine name behind you, your head in front of the letters, cover lines on the sides.
**When to use it:** When you present a topic like "big news", or for episode titles.

```
effects/cover_story.py: add a "Cover Story" effect between [START S] and [END S].

- Lay the image out like a magazine cover: an 18 px white border at the edges (a thin paper feel).
- At the top, across the full width of the screen, the magazine name in a huge, high-contrast serif font
  (Didot / Playfair Display Black): "[MAGAZINE NAME, e.g. EDIT]"
  - The letters are white and BEHIND the person mask: my head goes in front of the letters
    (as on real magazine covers)
- Cover lines: small, uppercase, spaced sans-serif text on the left and right edges:
  "[HEADLINE 1]", "[HEADLINE 2]", "[HEADLINE 3]"
  and at the bottom a single line of large italic serif main headline: "[MAIN HEADLINE]"
- Bottom left, a small barcode and an "ISSUE [NO] · [MONTH YEAR]" label.
- Animation: the magazine name slides up from below letter by letter (50 ms apart),
  the cover lines fade in. The image is slightly warm, film-toned and grainy.
- At the moment it appears, a 2-frame white flash and a short freeze (6 frames) that feels like a shutter sound.
```

---

# 17. Glass Type

**What it does:** A big word appears in 3D glass/chrome letters standing in the room behind you. The letters reflect the surroundings and rotate slightly.
**When to use it:** When you highlight the main topic or the key word of the video.

```
effects/glass_type.py: add a "Glass Type" effect between [START S] and [END S].

- Build the word "[WORD, e.g. DESIGN]" as 3D, bold, extruded (60 px depth) glass letters.
  Use Blender for this (from the command line, with a Python script) or three.js + Playwright:
  - Material: semi-transparent glass (IOR 1.45, slightly frosted), bright chrome reflections on the edges
  - Use the video's own (blurred) frame as the environment reflection,
    so the letters reflect the colors of the room
  - Render a PNG sequence with a transparent background
- Place the letters on the wall behind me, a little above shoulder height, BEHIND the person mask.
- Animation: the letters fall in from above one by one (70 ms apart) and settle with a slight bounce,
  then the whole word sways very slowly ±8° on the Y axis (4 s loop).
- A soft shadow of the letters on the wall, and a highlight that matches the room's light.
- If installing Blender is hard, imitate the same look in 2D (gradient + inner shadow + highlight
  lines + a slight refraction/displacement).
```

---

# Combining effects

To use several effects in one video:

```
Look at words.json for input.mp4 and split the video into scenes. Build the final video with this plan:

[0.0 – 2.5 s]  → Frame Break (opening)
[2.5 – 6.0 s]  → Digital Zoom
[6.0 – 9.0 s]  → Couch Wall
[9.0 – 12.0 s] → Checklist
[12.0 – 15.0 s]→ Doodle Boil
[15.0 – end]   → Chart Grow

- Use the Zoom-Through Cut on scene transitions.
- The captions keep the same style through the whole video.
- Don't render each effect separately and join them; process them layer by layer on one timeline
  so the transitions are smooth.
- Give me a quick low-resolution 540x960 preview first; if I approve it, render the final at 1080x1920.
```

> 💡 **Tip:** If you're not sure which effect fits where, write: *"Read words.json, pick the 5-6 best effects for this video's content from the 17 in this guide, and suggest where to put each one as a table. Apply it if I approve."*

---

# Fix prompts

**Timing:**
```
The [EFFECT] effect starts at [X] s; make it start exactly with the word "[WORD]".
Use the word time from words.json.
```

**Feel of the motion:**
```
[ELEMENT] moves too mechanically. Give it a 6% overshoot on entry (easeOutBack) and
a slight anticipation on exit. Change its duration from [X] ms to [Y] ms.
Don't touch anything else.
```

**Mask problem:**
```
The edges of the person mask flicker around [S] / my hair gets cut off.
In that part, smooth the mask more strongly over time, widen the edge by 1 px
and re-render only that range.
```

**Quality:**
```
The final render looks blurry. Use Lanczos for scaling, lower the CRF to 16,
set the bitrate to at least 20 Mbps and compare the sharpness with the source video.
```

**Preview:**
```
Export a 5-frame contact sheet (frames side by side) PNG of the [EFFECT] effect at [S],
so we can look at the problem together.
```

---

# Bonus: turn all of this into a skill

Instead of pasting prompts every time, save it once as a skill. Then all you need to write is *"/video-effects add couch wall"*:

```
Turn the effects toolkit we wrote in this project (fx.py, the effects/ folder, the caption style,
the render settings) into a reusable Claude Code skill.

- Skill name: video-effects
- Put SKILL.md and the scripts it needs under ~/.claude/skills/video-effects/
- In SKILL.md: when to use it, the setup steps, a short description of the 17 effects,
  the parameters each effect takes, and my style rules
- When I say "add [effect] to input.mp4" in a new folder, it should run the setup automatically

When it's done, try the skill on a new test video and show me the result.
```

---

# FAQ

**Does it work without Claude Code, just in a claude.ai chat?**
Partly. In a chat Claude can write the code, but to process your video frame by frame and render it you need **Claude Code** running on your computer.

**My computer is slow and rendering takes very long.**
Ask for a low-resolution (540×960) preview first, and render full resolution only for the final. Since the person mask is extracted once and saved, later renders are faster.

**The effect didn't turn out the way I wanted.**
That's normal 🙂 The first try is rarely perfect. Fix it step by step as in the "Fix prompts" section, naming the scene and the element. Adding a screenshot of a video you like and saying *"give it this feel"* also helps a lot.

**Do videos with a plain wall in the background work better?**
Yes. A simple background and good light make the person mask much cleaner. That directly improves effects like Frame Break, Doodle Boil and Glass Type.

---

I share new effects and workflows every week. Follow: **@fatihturkmen.ai** 🎬

---

From AI Creator Library: every effect with its example video at https://aicreatorlibrary.com/free-video-effects/