Video editing

TITLE: BAKER_60S_V1
FCM: NON-DROP FRAME
 
001  A001C003 V     C        01:02:10:05 01:02:18:12 00:00:00:00 00:00:08:07
002  A001C007 V     C        01:05:44:00 01:05:49:10 00:00:08:07 00:00:13:17

[shot size: extreme wide | wide | medium | close-up | extreme close-up], [angle, e.g. low angle], of
[subject, e.g. a baker's flour-covered hands] [one action, e.g. pressing and folding dough]
in [setting and time, e.g. a small bakery kitchen before dawn].
Camera: [camera move: static | slow push-in | pan | tilt | tracking | handheld].
Lens: [lens, e.g. 50 mm, shallow depth of field].
Lighting: [lighting, e.g. warm light from a single bulb, blue window light].
Style: [style, e.g. documentary, natural color, subtle grain], to match footage shot on [camera, e.g. a Sony FX3 at 5600 K].
Motion: [pace, e.g. slow, calm]. Audio: [audio, e.g. kitchen ambience only, no music, no dialogue].
Duration [seconds, e.g. 5] s, aspect ratio [aspect ratio: 16:9 | 9:16 | 1:1], [frame rate: 24 | 25 | 30] fps.

<context>
I have footage to edit into a video and I'm not an editor. What it
is: [one or two sentences, e.g. "a 40-minute interview with a baker
who left finance, plus some bakery footage"]. Where it goes: [e.g.
Instagram, maybe YouTube too].
</context>
 
<task>
Interview me before any edit is planned. I'll use my answers to
brief an edit plan: a paper edit from the transcript, with pacing
and platform specs.
</task>
 
<requirements>
- At most 10 questions, grouped under: Story, Viewer and platform,
  Material, Structure, Delivery and rules.
- Cover the one-sentence story; the feeling at the end; the hook;
  who watches, where, and with sound on or off; length; the footage
  and transcript I have; the frame rate; the structure (three-act or
  hook-body-payoff); music and its license; captions; versions; and
  whether soundbites may be joined across answers.
- For each question: why it matters, and 2–3 typical answers.
</requirements>
 
<output_format>
Numbered questions under the five group headings, each with a
"Why:" line and a "Typical:" line.
</output_format>
 
<process>
Ask the questions and stop. Don't plan the edit yet. When I have
answered, write my answers back as a brief of at most 12 bullets and
list what is still missing.
</process>

<materials>
[paste the brief from stage 1]
[paste the timecoded transcript]
</materials>
 
<task>
Propose 3 materially different structures for this video from the
same material, so I can pick one to build as a paper edit.
</task>
 
<requirements>
- The structures differ in order and shape, not only in the hook:
  for example a chronological three-act; a cold open on the
  strongest moment, then back to the start; hook-body-payoff built
  around one question.
- For each: the hook (timecode and exact words); the beats in order,
  each with its soundbite and timecodes; the turn; the last line; the
  estimated running time; what is lost; the B-roll it needs; the
  risks (meaning changed by reordering, a missing shot).
- Only words that are in the transcript.
- Never invent numbers, names, quotes or sources: write [CHECK
  TIMECODE] where a timecode is uncertain.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- Each structure tells the one-sentence story by the end.
- Each hook is in the footage and isn't misleading.
- The three would feel different to a viewer, not just reordered.
</quality_bar>
 
<output_format>
One short table per structure (beat | in–out | exact words), then a
comparison table and a recommendation in 3 sentences: which, why,
and what would change your mind.
</output_format>
 
<process>
Stop after the recommendation and wait for my choice. End with a
list of the assumptions you made.
</process>

<materials>
[paste the brief and the structure you chose]
[paste the timecoded transcript, with speaker labels]
[paste the B-roll log: clip name, timecode, what is in it]
</materials>
 
<context>
Video: [one-sentence story, e.g. "she traded money for mornings she
loves, and doesn't regret it"], for [audience, e.g. people thinking
about a career change].
Format: [format: interview documentary | explainer | vlog | multicam podcast | promo]
Footage: [cameras, resolution and frame rate, e.g. two angles, 4K,
23.976 fps].
Editor: [editor: Premiere Pro | DaVinci Resolve | Final Cut Pro | CapCut]
Versions: [versions: 9:16 Reels/TikTok/Shorts | 16:9 YouTube | 4:5 feed | 1:1 feed], length [e.g. 60 s].
Music: [track, BPM and license, e.g. "one acoustic track, 92 BPM,
licensed for social"].
</context>
 
<examples>
Edits I like: [1–2 videos, each with what to take, e.g. "calm
pacing, holds on faces, no whooshes"]
One I don't: [one, with why, e.g. "a jump cut every second"]
</examples>
 
<task>
Write an edit plan: a paper edit I can assemble from, a B-roll and
sound plan, a pacing map and the delivery specs, so I can build the
rough cut and export every version.
</task>
 
<requirements>
- Paper edit: each soundbite with source clip, in and out timecode,
  speaker and exact words; any cut inside a sentence marked [CUT];
  no join across answers that changes the meaning (no frankenbites).
  Enter late, leave early.
- The chosen structure, with its beats labeled (hook, body beats and
  payoff, or the three acts); the hook in the first seconds.
- For each soundbite: the B-roll that covers it, and a J-cut or
  L-cut where the sound should lead or trail the picture.
- A pacing map: running time per beat, where to hold on emotion,
  where the music changes; cut choices by Murch's rule of six
  (emotion and story before rhythm).
- Delivery per version: aspect ratio and resolution, the frame rate
  as shot, codec and container, captions (at most 42 characters per
  line and 2 lines), loudness about −14 LUFS integrated and −1 dBTP
  true peak for web (−23 LUFS, EBU R 128, for broadcast).
- An event list in CMX 3600 EDL fields at the project frame rate.
- Never invent numbers, names, quotes or sources: write [CHECK
  TIMECODE] where a timecode or word isn't in the transcript, and
  [NEEDS SOURCE] for any fact said on screen.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- Every soundbite's words and timecodes match the transcript
  exactly.
- The running time adds up to the target, beat by beat.
- The one-sentence story is clear by the end; every beat earns its
  place.
- Each version's specs match its platform: aspect ratio, safe area,
  loudness, captions.
</quality_bar>
 
<output_format>
1. A paper edit table (# | beat | clip | in | out | exact words |
B-roll | J/L cut | running total). 2. A pacing map (beat | seconds |
note). 3. Music and sound notes, at most 5 bullets. 4. A delivery
table, one row per version (aspect ratio | resolution | fps | codec
| captions | loudness). 5. The EDL event list as plain text.
</output_format>
 
<process>
Ask me up to 3 questions first if anything missing would change
your answer; otherwise go on. End with a list of the assumptions you
made.
</process>

<materials>
<transcript>
[paste the timecoded transcript]
</transcript>
<brief>
[paste the brief]
</brief>
<draft>
[paste the edit plan]
</draft>
</materials>
 
<task>
Review this edit plan before I assemble it. This is a fresh chat:
judge it only against what is here.
</task>
 
<requirements>
- For every soundbite: quote the transcript line it came from, with
  its timecode; flag any mismatch in words or timecodes, any cut
  inside a sentence not marked [CUT], and any join that changes the
  meaning.
- Score each check 1–5 with one line of evidence: story; hook;
  pacing; cuts (motivated, J- and L-cuts placed); truthfulness; the
  sound plan; specs per platform; rights (music, generated shots).
- Add up the running time and compare it with the target.
- Don't rewrite the plan. Don't praise it.
- Never invent numbers, names, quotes or sources: write [CHECK
  TIMECODE] where you can't find a line.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- Every flag quotes the transcript.
- Fixes are ranked by their effect on the viewer, worst first.
</quality_bar>
 
<output_format>
A verification table (# | words in the plan | words in the
transcript | match), a score table, then at most 7 fixes ranked.
</output_format>
 
<process>
End with a list of the assumptions you made.
</process>

Write a script for a [length, e.g. 60-second] [platform: Reels | TikTok | Shorts | YouTube]
video for [audience, e.g. first-time founders]: a table of time range,
spoken words, and B-roll or on-screen text per line, at about 140
words per minute, with 3 hook options under 8 words. Check the word
count fits the length, and mark claims I must verify [NEEDS SOURCE].

<materials>
[paste key facts, notes or an outline, or write "none"]
</materials>
 
<context>
Video: [length, e.g. 90 s] for [platform: Reels | TikTok | Shorts | YouTube | LinkedIn], [aspect ratio: 9:16 | 16:9 | 4:5 | 1:1].
Audience: [who, e.g. people thinking about a career change].
Goal: [what viewers should think, feel or do, e.g. "book a trial class"].
Speaker: [who, and how they talk, e.g. "the baker: plain, warm,
short sentences"].
Viewing: [sound: mostly muted | mostly sound on].
</context>
 
<examples>
Scripts or videos I like: [1–2, each with what to take, e.g. "talks
straight to camera, one idea per line"]
One I don't: [one, with why, e.g. "opens with 'hi guys'"]
</examples>
 
<task>
Write a shooting script, so the speaker can record it and I can plan
the B-roll from it.
</task>
 
<requirements>
- Structure: [structure: hook-body-payoff | three-act | problem-solution | list].
- Spoken words at about 130–160 words per minute; state the word
  count.
- 3 alternative hooks under 8 words; the first line also works
  muted, as on-screen text.
- B-roll or on-screen text for every line, from things that can be
  filmed.
- Must include: [facts and the call to action, e.g. "classes start
  in May; link in bio"].
- Never invent numbers, names, quotes or sources: write [NEEDS
  SOURCE] for any claim I must verify.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- The hook gives a reason to stay within the first seconds.
- The word count fits the length at the speaker's pace.
- Read aloud, every line sounds like the speaker.
- Every line has a picture.
</quality_bar>
 
<output_format>
The 3 hooks, then a table (time range | spoken words | B-roll or
on-screen text), then the word count and running time.
</output_format>
 
<process>
Ask me up to 3 questions first if anything missing would change
your answer; otherwise go on. End with a list of the assumptions you
made.
</process>

From this script [paste], make a shot list for [location, e.g. a small
bakery] with [crew and gear, e.g. 2 people, one camera, 24–70 mm]:
shot number, script line, size, angle, movement, lens, action, audio,
duration, priority. Group by setup, mark gaps stock or a video
generator could fill, and check every script line is covered.

<materials>
[paste the script or paper edit]
[paste the footage log, if some is already shot]
</materials>
 
<context>
Shoot: [location and time, e.g. a small bakery, 5–9 a.m.], crew of
[number, e.g. 2], [camera and lenses, e.g. one mirrorless camera,
24–70 mm], [hours, e.g. 4] to shoot.
Delivery: [aspect ratio: 16:9 | 9:16 | both], at [frame rate: 23.976 | 24 | 25 | 29.97 | 30] fps.
Footage look: [e.g. "natural light, 35 mm feel, slight grain"].
</context>
 
<task>
Write a shot list and a B-roll gap plan, so the shoot covers every
line and I know how each gap gets filled.
</task>
 
<requirements>
- Columns: shot number; the script line it covers; shot size (EWS to
  ECU); angle; camera movement; lens; action; audio needs; duration;
  priority (must or nice).
- Grouped by setup to save time; the 180° rule kept for two-person
  scenes.
- 5 cutaways or inserts that can cover jump cuts in the interview.
- For each line with no coverage: film it, use stock, use a screen
  recording or generate it. For generated shots, a video-generation
  prompt: shot size, subject, one action, setting, one camera move,
  lens, lighting, style matched to the footage look, duration,
  aspect ratio and frame rate.
- No generated shots that need readable text, logos, hands doing
  precise work, or real people's faces.
- Never invent numbers, names, quotes or sources: write [NEEDS
  SOURCE] where support is missing.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- Every script line has at least one shot.
- The list fits the hours given (durations plus setup changes).
- Generated shots match the real footage in lens, light and color.
</quality_bar>
 
<output_format>
The shot list as a table grouped by setup, then a gap table (script
line | solution | generation prompt, if generated).
</output_format>
 
<process>
Ask me up to 3 questions first if anything missing would change
your answer; otherwise go on. End with a list of the assumptions you
made.
</process>

From this transcript of a [source, e.g. 45-minute podcast] [paste], find
the 3 best moments for [platform: Reels | TikTok | Shorts] clips of [clip length, e.g. 30–60 s]:
in and out timecodes, why each stands alone, 5 on-screen hooks under 8
words, and where to punch in or add B-roll. Exact words only; check
each clip makes sense to someone who hasn't seen the rest.

<materials>
[paste the timecoded transcript, with speaker labels]
</materials>
 
<context>
Source: [what it is, e.g. a 50-minute video podcast, two cameras].
Clips for: [platform: Reels | TikTok | Shorts], 9:16, [clip length, e.g. 30–60 s].
Audience: [who, e.g. small-business owners].
Viewing: mostly muted, so the captions carry the story.
</context>
 
<examples>
Clips I like: [1–2, each with what to take, e.g. "opens mid-sentence
on the punchline, then explains"]
One I don't: [one, with why, e.g. "the hook is a tease the clip
never pays off"]
</examples>
 
<task>
Pick and plan [number, e.g. 3] short clips, so I can cut them
without watching the whole source again.
</task>
 
<requirements>
- Each clip stands alone: it makes sense to someone who hasn't seen
  the rest, with its own hook, body and payoff.
- In and out timecodes and exact words; any cut inside a sentence
  marked [CUT]; no change of meaning.
- 5 hook options per clip: on-screen text under 8 words, plus a
  spoken opener if the clip should start elsewhere.
- Something changes on screen every few seconds (punch-ins, B-roll,
  on-screen text), with timecodes.
- Burned-in captions inside the safe area, clear of the platform's
  buttons along the bottom and right.
- Never invent numbers, names, quotes or sources: write [CHECK
  TIMECODE] where a timecode is uncertain.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- Every hook is in the footage and isn't misleading.
- Each clip's running time is within the target.
- Each clip works watched muted, with captions only.
</quality_bar>
 
<output_format>
Per clip: a header (title, in–out, running time), a table (timecode
| words | on-screen change), the 5 hooks and the post caption.
</output_format>
 
<process>
Ask me up to 3 questions first if anything missing would change
your answer; otherwise go on. End with a list of the assumptions you
made.
</process>

Clean up this SRT from auto captions [paste]. Correct these names and
terms: [paste the list]. Fix punctuation and casing; at most 42
characters per line and 2 lines per caption; split at phrase breaks;
keep timecodes unless a caption must split. Return valid SRT, then
list every change, and check no other word changed.

<materials>
[paste the SRT or VTT file]
[paste names, places and terms with their correct spelling]
</materials>
 
<context>
Video: [what it is and who for, e.g. a bakery interview for adults].
Captions: [captions: open, burned in | closed, as a file | both]
Kind: [kind: same-language captions | SDH with sound cues | translated subtitles]
Platform: [e.g. Instagram Reels and YouTube].
</context>
 
<task>
Correct and reformat the caption file, so it is accurate, readable
and accepted on upload.
</task>
 
<requirements>
- House style from Netflix's English timed-text guide: at most 42
  characters per line and 2 lines, up to 20 characters per second
  for adult programs (17 for children's).
- Fix the spelling of the names and terms given, punctuation and
  casing.
- Split at natural phrase breaks; never split a name across lines.
- Keep every timecode unless a caption must split; then divide the
  time at the phrase break.
- For SDH: speaker IDs and sound cues in square brackets.
- Never invent numbers, names, quotes or sources: write [CHECK
  AUDIO] where you can't tell what was said; never guess a word.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- The file parses: sequential numbers, HH:MM:SS,mmm --> HH:MM:SS,mmm
  timings, a blank line between captions.
- No caption runs over 2 lines, 42 characters per line or 20
  characters per second.
- No word changed except the listed corrections.
</quality_bar>
 
<output_format>
The corrected file in one code block, then a change table (caption
number | before | after | reason).
</output_format>
 
<process>
End with a list of the assumptions you made.
</process>

My locked cut as sections with timecodes: [paste]. Music: [track, e.g.
2:40, 92 BPM, intro-verse-chorus-outro]. Make a music cue sheet (start,
changes, hits, ducks, an ending on a phrase that lands on the last
frame) and a sound plan (ambience, effects, room tone) for [target: web −14 LUFS | broadcast −23 LUFS].
Check that music never covers a line of dialogue without a duck.

<materials>
[paste the locked cut as sections: timecode in–out, what is said,
what is on screen]
</materials>
 
<context>
Music: [track, length, BPM and structure, e.g. "2:40, 92 BPM: intro
8 bars, verse, chorus, outro"], licensed for [use, e.g. social and
YouTube].
Delivery: [target: web about −14 LUFS | broadcast EBU R 128 −23 LUFS | US broadcast ATSC A/85 −24 LKFS | podcast feed −16 LUFS]
Editor: [editor: Premiere Pro | DaVinci Resolve | Final Cut Pro | CapCut]
</context>
 
<examples>
Mixes I like: [1–2 videos, each with what to take, e.g. "music almost
gone under speech, swelling only on B-roll"]
One I don't: [one, with why, e.g. "music pumps up between every
sentence"]
</examples>
 
<task>
Write a music cue sheet and a sound plan for the locked cut, so I
can finish the audio in one pass.
</task>
 
<requirements>
- Cue sheet: where music starts, changes, hits a beat and ends;
  edit points on musical phrases; the ending lands on the last frame.
- Ducking: where music drops under dialogue, by how many dB, and
  the fade lengths, without pumping.
- Sound plan: ambience per scene, effects for B-roll that would
  otherwise be silent, room tone under every gap.
- Loudness: the integrated target and the true-peak ceiling,
  measured on the full mix with an ITU-R BS.1770 meter.
- Never invent numbers, names, quotes or sources: write [NEEDS
  SOURCE] where support is missing, and label dB amounts as starting
  points to set by ear.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- No music sits under speech without a duck.
- Every music edit falls on a phrase boundary.
- Every B-roll shot has sound.
- The loudness targets match the delivery chosen.
</quality_bar>
 
<output_format>
A cue table (timecode | music event | level | note), a sound table
(timecode | ambience or effect | source), and the mix targets in 3
lines.
</output_format>
 
<process>
Ask me up to 3 questions first if anything missing would change
your answer; otherwise go on. End with a list of the assumptions you
made.
</process>

I shot [camera and log profile, e.g. Sony FX3, S-Log3] for SDR web,
editing in [editor: Premiere Pro | DaVinci Resolve | Final Cut Pro]. Give me the color order
(normalize to Rec.709, correct, match, grade, secondaries), the scopes
to read for exposure and skin, and how to build a [look, e.g. warm
early-morning] look from basic tools. Check skin on the vectorscope.

<materials>
[optional: describe or attach stills of the problem shots]
</materials>
 
<context>
Footage: [camera and log profile, e.g. Sony FX3, S-Log3 and S-Gamut3.Cine], white balance [e.g. 5600 K, fixed].
Delivery: [delivery: SDR Rec.709 web | SDR broadcast | HDR]
Editor: [editor: Premiere Pro | DaVinci Resolve | Final Cut Pro]
Scenes: [list, e.g. interview angle A, angle B, bakery B-roll under
mixed light].
</context>
 
<examples>
Looks I like: [1–2 films or videos, each with what to take, e.g.
"soft contrast, warm highlights, natural skin"]
One I don't: [one, with why, e.g. "crushed teal-and-orange"]
</examples>
 
<task>
Write color notes and a pipeline for this project, so every shot is
corrected, matched and graded in the right order.
</task>
 
<requirements>
- Order: normalize log to Rec.709 (the maker's LUT or a color space
  transform); correct exposure, white balance and contrast; match
  the shots in each scene; grade; then secondaries.
- Per scene: the correction issues to look for and the shot to
  match to.
- Scopes: what to read on the waveform, RGB parade and vectorscope
  for exposure, balance and skin tones.
- The look as basic adjustments (curves, color wheels, saturation),
  not a downloaded creative LUT.
- Never invent numbers, names, quotes or sources: write [NEEDS
  SOURCE] where support is missing, and label values as starting
  points.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- No creative look goes on before normalizing and correcting.
- Skin tones are checked against the vectorscope's skin-tone line.
- The grade is checked on a calibrated display and on a phone.
</quality_bar>
 
<output_format>
The pipeline as numbered steps for the chosen editor, a per-scene
table (scene | issue | fix | match to), and the look as a recipe.
</output_format>
 
<process>
Ask me up to 3 questions first if anything missing would change
your answer; otherwise go on. End with a list of the assumptions you
made.
</process>

I'm delivering [project, e.g. a 3-minute brand film] as [versions, e.g.
YouTube 16:9, Reels 9:16, a master]. Source: [e.g. 4K, 23.976 fps,
Rec.709]. Make a delivery table (container, codec, resolution, fps, bit
rate, audio, loudness, captions, file name) and a QC checklist, and
mark [VERIFY] beside every platform spec to confirm on its help page.

<materials>
[optional: the client's delivery spec, or the platform help pages
you checked]
[paste the cut list: sections with timecodes]
</materials>
 
<context>
Project: [what it is, e.g. a 3-minute brand film and its cutdowns].
Source: [resolution, frame rate and color space, e.g. 4K, 23.976
fps, Rec.709].
Versions: [versions: 16:9 YouTube | 9:16 Reels/TikTok/Shorts | 4:5 feed | 1:1 feed | master | review link]
Editor: [editor: Premiere Pro | DaVinci Resolve | Final Cut Pro | CapCut]
</context>
 
<task>
Write a delivery spec and a QC checklist, so every version exports
correctly and nothing broken reaches a platform or the client.
</task>
 
<requirements>
- Per version: container and codec; resolution; the frame rate as
  shot; bit rate; audio codec and sample rate; loudness; captions
  (burned in or a file); safe areas; file name.
- YouTube per Google's recommended upload settings; the master as
  ProRes 422 HQ or DNxHR HQ with PCM audio and separate stems; the
  review link with timecode burned in.
- A QC checklist with timecodes from the cut list: flash frames,
  black frames, sync, audio pops, caption errors and timing, text
  under platform UI, loudness jumps between sections, the end card.
- Never invent numbers, names, quotes or sources: write [VERIFY]
  beside each platform spec I should confirm on its current help
  page.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- Every version keeps the source frame rate.
- Nothing important sits under the platform UI in vertical versions.
- Every loudness value matches its destination.
</quality_bar>
 
<output_format>
A delivery table with one row per version, then the QC checklist as
checkboxes with timecodes.
</output_format>
 
<process>
Ask me up to 3 questions first if anything missing would change
your answer; otherwise go on. End with a list of the assumptions you
made.
</process>

Review my rough cut, given as sections with timecodes, words and
pictures: [paste]. Goal: [e.g. viewers book a class]; target [e.g. 60
s], now [e.g. 1:35]. Notes in order: story, pacing, clarity, then cuts,
each with timecode, problem and fix, plus what to lose to hit the
target. Skip color and sound, and check every note names a timecode.

<materials>
<brief>
[paste the brief or the one-sentence story]
</brief>
<cut>
[paste the cut as sections: timecode in–out, what is said, what is
on screen]
</cut>
</materials>
 
<context>
Stage: [stage: assembly | rough cut | fine cut]
Length: target [e.g. 60 s], now [e.g. 1:35].
Platform: [platform: Reels | TikTok | Shorts | YouTube | LinkedIn]
</context>
 
<examples>
A cut I'd like this to feel like: [one video, with what it does
well]
</examples>
 
<task>
Give editor's notes on the cut, so I know what to change before the
next version.
</task>
 
<requirements>
- Notes in priority order: story and structure, then pacing, then
  clarity, then individual cuts (Murch's rule of six: emotion and
  story before rhythm and eye-trace).
- For each note: the timecode, the problem and a specific fix.
- What to cut to reach the target length, with timecodes.
- Notes that fit the stage: at a rough cut, structure, not trims.
- Don't comment on color or sound yet. Don't rewrite the cut.
- Never invent numbers, names, quotes or sources: write [CHECK
  TIMECODE] where a timecode is uncertain.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- Every note names a timecode.
- After the fixes, the one-sentence story is clear by the end.
- The proposed cuts add up to the seconds needed.
</quality_bar>
 
<output_format>
A notes table (priority | timecode | problem | fix), then the cut
list (timecode | seconds saved | running total).
</output_format>
 
<process>
Ask me up to 3 questions first if anything missing would change
your answer; otherwise go on. End with a list of the assumptions you
made.
</process>

Edit my interview with the baker into a cool short video for
Instagram.

<materials>
<transcript>
[paste the timecoded transcript of the 40-minute interview]
</transcript>
<broll>
[paste the B-roll log: clip, timecode, what is in it]
</broll>
</materials>
 
<context>
A 40-minute interview with a baker who left a finance job: two
angles, 4K, 23.976 fps, plus 15 minutes of bakery B-roll. The video
is for people considering a career change. Story in one sentence:
"she traded money for mornings she loves, and doesn't regret it."
Feeling at the end: hopeful, a little defiant.
</context>
 
<task>
Build a paper edit for a 60-second Instagram Reel, so I can assemble
it in DaVinci Resolve.
</task>
 
<requirements>
- Hook-body-payoff: a hook in her own words, three beats, a last
  line.
- Each soundbite: clip, in and out timecodes, exact words; any cut
  inside a sentence marked [CUT]; never join answers in a way that
  changes what she meant.
- About 55 s of speech in total.
- For each soundbite, the B-roll from my log that covers it, and a
  J-cut or L-cut into it where that helps.
- One music change, placed by timecode.
- 9:16 with burned-in captions; most viewers watch muted.
- Never invent numbers, names, quotes or sources: write [CHECK
  TIMECODE] where you can't find a line in the transcript.
</requirements>
 
<quality_bar>
Before answering, check your draft against:
- Every soundbite's words and timecodes match the transcript.
- No join changes her meaning.
- The running time adds up to about 55 s.
- The first line works as on-screen text with the sound off.
</quality_bar>
 
<output_format>
Five hook options (timecode and exact words), then a table: # | beat
| clip | in | out | exact words | B-roll | J/L cut | running total.
Then the music change in one line.
</output_format>
 
<process>
Ask me up to 3 questions first if anything missing would change your
answer; otherwise go on. End with a list of the assumptions you made.
</process>

Hooks
1  00:04:12:08  "I made more money and hated every day."
2  00:22:40:02  "Four a.m. is my favorite hour now."
...
 
#  Beat    Clip      In           Out          Exact words                               B-roll               Cut  Total
1  Hook    A001C003  00:04:12:08  00:04:15:20  "I made more money and hated every day."   -                    -    3.5 s
2  Then    A001C003  00:06:01:12  00:06:13:00  "I'd sit in the quarterly review          B07 office window,   L    15.0 s
                                               counting ceiling tiles. [CUT] I knew I'd   dusk
                                               do that for thirty more years."
3  Turn    A001C004  00:18:22:00  00:18:34:12  "My grandmother's starter sat in my        B03 starter jar,     J    27.5 s
                                               fridge for six years. One Saturday I       hands
                                               baked with it..."
4  Now     A001C005  00:22:40:02  00:22:56:02  "Four a.m. is my favorite hour now. [CUT]  B11 ovens at dawn    L    43.5 s
                                               It's just me, the ovens and the radio..."
5  Payoff  A001C003  00:12:41:03  00:31:09:12  "I don't miss it. The money was never      B15 her, smiling     -    48.5 s
                                               the point."
6  End     A001C005  00:38:02:10  00:38:08:10  "If you're thinking about it, start on     -                    -    54.5 s
                                               a Saturday."
 
Music change at 27.5 s (row 3, the turn): sparse piano into the full
acoustic track.
Assumptions: B-roll codes refer to your log; she is happy for the
grandmother story to be used.

Row 5 joins 00:12:41 ("I don't miss it", which is about the commute)
to 00:31:05, where she says "I do miss the money, honestly. But the
money was never the point." The join reverses her meaning. Replace
row 5 with one continuous soundbite that makes the payoff in her own
words (00:31:05:00–00:31:09:12, kept whole, is a candidate), or keep
a join only if her meaning survives, marked [CUT]. Then quote the
transcript line and timecode for every row, and update the running
total.