Prompts for Video and Editing: How to Assemble a Commercial, Reels, and a YouTube Episode Without a Video Editor

Prompts for Video and Editing: How to Assemble a Commercial, Reels, and a YouTube Episode Without a Video Editor

A 40-second Reels that used to take a day of editing now gets assembled in a couple of hours — not because you became a colorist overnight, but because the boring 80% of video production (script, shot list, subtitles, b-roll selection, metadata) is text work. And text work is exactly what LLMs do best. The actual editing — cutting clips, adding transitions, rendering — still happens in CapCut, DaVinci Resolve, or Premiere. But you walk into the timeline with a plan instead of a blank canvas.

This is a collection of prompts I actually use in my workflow, tested on real projects: a product commercial for a small SaaS, a series of vertical Reels, and a 12-minute YouTube episode. Each prompt is complete, with a usage example and the reasoning behind it. The goal is a repeatable pipeline: problem → solution → result, where AI handles the cognitive load and you handle the creative decisions.

A quick technical note before we start: all prompts assume a modern multimodal LLM (GPT-4o/5-class, Claude 3.5+/4, Gemini 1.5 Pro+). For video understanding, use models that accept video input — Gemini 1.5 Pro accepts video directly via the Files API, and GPT-4o can process sampled frames. Everything below works with text-only models too, as long as you feed them transcripts and descriptions.

1. The Brief Decomposer: From "Make a Reel" to a Structured Shot List

The most common failure in AI-assisted video is a vague input. "Make me a Reels about our new feature" produces generic garbage. This prompt forces the model to decompose the goal into a structured production document before generating anything creative.

You are a senior video producer. I'll give you a raw brief. Do NOT write a script yet.
First, produce a structured breakdown:
1. Objective (one sentence, measurable)
2. Target platform + aspect ratio + max duration
3. Core message (one sentence a viewer should remember)
4. Hook options (3 variants, each ≤7 words for the first 3 seconds)
5. Required shots (numbered list: shot type, duration, on-screen text, audio note)
6. Assets I need to provide (footage, logos, screenshots)
7. Risks / what could make this video fail

Brief: [YOUR BRIEF]

Example: Brief — "Reels for our task manager app, target audience is freelancers, want to show the AI scheduling feature." The model returned a 6-shot breakdown: hook ("Stop planning. Start shipping."), screen recording of drag-and-drop, split-screen before/after, CTA with a 3-second app store badge. Total planned duration: 34 seconds — within the 60-second Reels limit.

Why it works: it separates planning from generation. Most people ask for the script immediately and then wonder why the result is generic. Planning first gives you a document you can actually shoot against.

2. The Hook Generator: 3 Seconds That Decide Everything

On Reels and TikTok, retention at 3 seconds is the metric that determines distribution. Instagram's own creator guidance (help.instagram.com, "Reels" section) repeatedly emphasizes the first seconds. This prompt generates hooks calibrated to different psychological triggers.

Generate 10 hooks for a [PLATFORM] video about [TOPIC].
For each hook, specify:
- The exact text (≤10 words, spoken or on-screen)
- The psychological trigger (curiosity gap / loss aversion / pattern interrupt / social proof / contrarian claim)
- The visual that should accompany it (first frame)
- Why it could fail

Rules: no clickbait that the video can't deliver on. No "You won't believe...".
Audience: [DESCRIBE AUDIENCE]. Tone: [TONE].

Example output for a budgeting app:

Why it works: forcing the model to list failure modes kills the laziest hooks before you waste a shoot on them.

3. Script With Timecodes: The Bridge Between Words and Timeline

A script without timecodes is a blog post. This prompt outputs a shooting script where every line maps to a timeline position — which is exactly the format you'll paste into your editor's notes or a teleprompter app.

Write a [DURATION]-second script for a [FORMAT] video.
Output as a table with columns:

| Timecode | Visual | Voiceover / on-screen text | Audio | Shot type |

Rules:
- Spoken pace: ~2.5 words per second (English), adjust if language is [LANGUAGE]
- Every 3-5 seconds, a visual change (cut, zoom, text pop)
- No sentence longer than 12 words
- Mark [B-ROLL] where stock footage can replace a shoot

Topic: [TOPIC]. Key points to cover: [LIST]. CTA: [CTA].

Example row:

Why it works: the 2.5 words/second rule is a real constraint from voiceover practice (audiobook and narration standards typically sit between 140–160 words per minute, i.e. ~2.3–2.7 wps). It prevents the classic mistake of writing a 90-second script for a 60-second slot.

4. The Shot List Extractor: Turning a Script Into a Shooting Plan

Once you have the script, you need to know what to actually film. This prompt converts the script table into a deduplicated shot list you can hand to a camera operator (or to yourself).

Here is my script: [PASTE SCRIPT TABLE]
Extract a production shot list. Group identical setups.
For each shot output:
- Shot ID
- Description
- Location (indoor/outdoor/studio/screen recording)
- Equipment needed
- Estimated setup time (minutes)
- Can it be replaced by stock footage? (yes/no + search keywords)

Sort by shooting efficiency (group by location), not by script order.

Why it works: sorting by location instead of script order can cut a shoot day significantly. If you have three indoor shots and two outdoor, you don't want to run in and out of the building five times.

5. Subtitle Generator With Platform-Specific Formatting

Auto-captions exist in every editor, but they're rarely formatted for readability. This prompt takes a raw transcript and produces properly segmented subtitles — and, critically, generates the SRT structure you can paste into a file.

Take this transcript: [PASTE TRANSCRIPT]
Produce subtitles with these rules:
- Max 42 characters per line, max 2 lines per cue
- Max 2.5 seconds per cue (reading speed)
- Break at natural phrase boundaries, never mid-phrase
- Remove filler words (um, uh, like) unless they carry meaning
- Output as an SRT block: index / start --> end / text

Then output a second version: "burn-in style" — punchy 3-5 word chunks for Reels.

Transcript: [PASTE]

Example output (SRT):

1
00:00:00,000 --> 00:00:02,400
Stop planning.
Start shipping.

2
00:00:02,400 --> 00:00:05,100
One drag, and the AI
reschedules everything.

Why it works: the 42-character and 2.5-second limits come from broadcast subtitle conventions (BBC and Netflix subtitle style guides both specify similar reading-speed constraints). Auto-captions ignore these and produce unreadable walls of text.

6. B-Roll Finder: Descriptive Search Queries for Stock Libraries

Stock libraries are keyword-based, and most people search badly. This prompt turns your script into precise search queries for Pexels, Pixabay, Envato, or Storyblocks.

For each line in this script, generate 3 stock footage search queries.
Rules:
- Use concrete nouns and camera terms ("overhead shot", "slow motion", "close-up hands")
- Avoid abstract words ("success", "innovation") — they return generic results
- Include 1 safe query, 1 creative query, 1 "unexpected" query
- Note the ideal duration and orientation (vertical for Reels, horizontal for YouTube)

Script: [PASTE]

Example for the line "Your morning routine, minus the panic":
- Safe: slow motion coffee pour close up (5s, vertical)
- Creative: overhead desk morning light notebook (4s, vertical)
- Unexpected: steam rising from cup dark background (3s, vertical)

Why it works: "success" returns a man in a suit jumping. "Steam rising from cup dark background" returns something usable. Concrete nouns are the difference between 20 minutes of scrolling and 2 minutes of picking.

7. Voiceover Direction: TTS Prompts That Don't Sound Like a Robot

If you're using text-to-speech (ElevenLabs, OpenAI TTS, Google Cloud TTS), the voice direction matters as much as the script. This prompt prepares the text and direction notes for TTS.

Prepare this script for text-to-speech synthesis.
Output:
1. Cleaned script with phonetic hints for tricky words
2. Pause markers ([short pause], [long pause]) inserted at logical breaks
3. Emphasis marks (CAPS or *asterisks*) on words that carry meaning
4. Recommended TTS settings: stability, similarity, speed (for ElevenLabs-style models)
5. A "human pass" list — words I should re-record manually if TTS fails

Script: [PASTE]. Target voice: [warm/male/female/neutral].

Why it works: TTS engines flatten prosody without explicit pause and emphasis cues. Inserting [short pause] between sentences and capitalizing the emotional keyword ("Stop PLANNING") measurably improves naturalness. ElevenLabs' own documentation recommends adjusting stability for expressive content — lower stability for more emotion, higher for consistency.

8. The Commercial Structure Template: AIDA, PAS, and 4P in One Prompt

For paid ads, structure beats creativity. This prompt generates a commercial script in three proven frameworks so you can A/B test the structure, not just the wording.

Write a [DURATION]-second video ad for [PRODUCT].
Generate 3 versions, each using a different framework:
- AIDA (Attention, Interest, Desire, Action)
- PAS (Problem, Agitation, Solution)
- 4P (Promise, Picture, Proof, Push)

For each version:
- Full script with timecodes
- The single strongest line (the one to put in the thumbnail/first frame)
- The weakest line (and how to fix it)
- Platform fit: [PLATFORM]

Product: [DESCRIPTION]. Audience: [AUDIENCE]. Main objection to overcome: [OBJECTION].

Example for a SaaS task manager: The PAS version opened with "You have 47 open tasks and no idea where to start" — a problem the audience recognizes instantly. The AIDA version led with a feature demo. Testing both told us PAS outperformed for cold audiences, AIDA for retargeting. That's a structural insight you can only get by generating both.

Why it works: frameworks aren't magic, but they prevent the most common ad failure — a script that describes the product instead of the viewer's problem.

9. YouTube Episode Outline: Retention Curve Engineering

A 12-minute YouTube video is not a long Reel. It needs a retention curve: a reason to stay at every minute. This prompt builds the outline with explicit retention devices.

Build an outline for a [DURATION]-minute YouTube video about [TOPIC].
For each segment output:
- Timestamp range
- Segment goal (what the viewer learns/feels)
- Retention device (open loop, pattern interrupt, story, payoff)
- Visual plan (talking head / screen / b-roll / graphic)
- The "exit risk" — why someone might click away here, and the countermeasure

Open with a hook in the first 30 seconds that states the payoff.
Close with a CTA that fits the content, not a generic "subscribe".

Example structure: 0:00–0:30 hook ("By the end of this video you'll have a script in your hands"), 0:30–3:00 problem framing with an open loop ("I'll show the fix in a minute"), 3:00–7:00 the method with a pattern interrupt at 5:00 (b-roll + music shift).

Why it works: YouTube's own creator resources emphasize that the first 30 seconds and the mid-video retention dips are the highest-leverage edits. Naming the exit risks forces you to plan countermeasures instead of discovering them in analytics after publishing.

10. Thumbnail and Title Pair Generator

Thumbnail and title work as one unit. This prompt generates them together, with a consistency check.

Generate 5 title + thumbnail concept pairs for a YouTube video about [TOPIC].
For each pair:
- Title (≤60 characters, front-load the keyword)
- Thumbnail concept: subject, expression, text overlay (≤4 words), color contrast note
- The "curiosity gap" the pair creates
- Consistency check: does the thumbnail promise match the title?

Avoid: clickbait that the video doesn't deliver, ALL CAPS titles, arrows and circles on thumbnails.

Example pair: Title — "I edited a Reel in 20 minutes with AI prompts". Thumbnail — split screen, timeline on left, phone on right, text overlay "20 MIN". Curiosity gap: how exactly. Consistency: the video shows the exact prompts, so the promise holds.

Why it works: generating titles and thumbnails together prevents the classic mismatch where the thumbnail promises something the title contradicts. YouTube's A/B testing tools ("Test & Compare") let you validate these pairs with real data.

11. Multi-Platform Repurposing: One Shoot, Five Formats

One recording session can feed a YouTube video, three Reels, a LinkedIn clip, and a blog embed. This prompt handles the repurposing plan.

I have a [DURATION]-minute recording about [TOPIC].
Create a repurposing plan:
1. YouTube: full episode, chapter markers, description with timestamps
2. Reels/TikTok: 3 vertical cuts — each with hook, 30-60s duration, and the exact source timestamp range
3. LinkedIn: one 90-second clip focused on a business insight
4. Blog: embed points where the video supports the text

For each output specify: aspect ratio, subtitle style, and the CTA.

Why it works: the hard part of repurposing is selection — which 60 seconds out of 12 minutes deserve their own Reel. The model scans the transcript for self-contained insights, which is faster than scrubbing the timeline manually.

12. The Editing Checklist Generator: What to Do in the Timeline

This prompt produces a step-by-step editing checklist tailored to your footage and platform — the document you keep open while working in CapCut or DaVinci.

Generate an editing checklist for a [FORMAT] video, [DURATION], [PLATFORM].
Organize by editing phase:
1. Assembly (rough cut order, which clips first)
2. Pacing (target cut frequency, where to cut faster/slower)
3. Audio (music ducking levels, voiceover normalization target: -16 LUFS for web)
4. Color (basic correction steps, LUT recommendation)
5. Text and graphics (where subtitles, lower thirds, end cards go)
6. Export settings (resolution, bitrate, codec for [PLATFORM])

Include common mistakes for this format.

Why it works: the -16 LUFS target for web audio is the loudness standard most streaming platforms normalize to (integrated loudness for stereo web content is typically -14 to -16 LUFS). Knowing this prevents the "my video sounds quieter than everyone else's" problem. Export settings for YouTube (H.264, high bitrate, 1080p or 4K) and Reels (1080×1920, 9:16) differ — the checklist keeps you from exporting the wrong ratio.

13. Feedback Loop: Analyzing Performance Data Into the Next Script

After publishing, the data tells you what to fix. This prompt turns analytics into actionable script changes.

Here is my video performance data: [PASTE METRICS — retention curve, CTR, average view duration, top drop-off timestamps].
Analyze:
1. Where the biggest drop-off happens and the most likely cause (script, pacing, topic, thumbnail mismatch)
2. Which segment performed best and why
3. 3 specific changes for the next video in this series
4. One hypothesis to A/B test

Be specific — reference timestamps. Do not give generic advice like "make better content".

Example insight: if the drop-off is at 0:45 and the script had a 30-second intro before the first value point, the fix is concrete — move the value point to 0:15. YouTube Analytics shows the retention curve with exact timestamps, so you can paste the drop-off points directly.

Why it works: it closes the loop. Most creators collect data and never convert it into script changes. This makes the next video measurably better than the last.

Putting It Together: The Actual Workflow

The pipeline that works for me, end to end:

1. Brief → shot list (prompt 1) — 15 minutes
2. Hooks + script with timecodes (prompts 2–3) — 30 minutes
3. Shot list + b-roll queries (prompts 4, 6) — 20 minutes
4. Shoot or screen-record — the only part AI can't do for you
5. Subtitles + TTS direction (prompts 5, 7) — 20 minutes
6. Editing checklist (prompt 12) — 5 minutes, then edit in CapCut/DaVinci
7. Thumbnail + title + repurposing (prompts 10–11) — 20 minutes
8. Publish, collect data, feed it back (prompt 13)

What used to be a two-day production for a single Reel now fits into an afternoon. Not because the editing got faster — it didn't — but because you stop staring at a blank timeline wondering what to cut. The AI handles the text layer: briefs, scripts, subtitles, metadata, repurposing plans. You handle the part that actually requires taste: the cut, the pacing, the color, the final call on which take is the good one.

The prompts above are starting points, not gospel. The best results come when you feed the model your own constraints — your platform, your audience, your footage. Take prompt 1, run it on your next brief, and see how much of the planning you can hand off before you touch the timeline. If you want a structured way to build these habits across a whole content operation — from brief to published video to performance analysis — that's the kind of workflow ASI Biont trains you to run end to end, with AI as the production assistant that never sleeps.