Guide

How to brief an AI editing agent from the shoot

By Trey Keys · November 3, 2026 · 8 min read

Your AI editing agent can only find the best moments in your footage if someone tells it where they are. The person best placed to do that is you, on set, while it happens. This guide walks through the whole loop: log notes on live timecode during the shoot, export them as markers in a CSV or XML file, and hand that file to Claude Code or to an agent driving DaVinci Resolve, with a prompt that tells it exactly how to read them.

Why I log notes on set

I make a podcast and a lot of shoot-day content. For a long time someone on our team watched every recording after the fact and pulled the moments for teasers and clips. When they left the organization, that context left with them. Nobody was watching all the footage anymore, and I couldn't afford to watch every hour twice.

So now I build the context myself, while it's happening. When I'm on a shoot I hit record and watch the conversation unfold. TCnotes runs in the background, and every time something feels clip-worthy I jot a fast note: a line, an idea, a "use this". The note is stamped to the frame, so that moment is never lost in the timeline again.

Those notes outlast the shoot. They stay in my account, they export as markers for Premiere Pro, Resolve and Final Cut Pro, and they're exactly the brief an AI editing agent needs. Hand an agent the notes and it already knows where the most valuable parts of the video are. The human side of editing gets better too: no second pass to find the good bits and drop markers. They're already there to grab.

1. Log notes on set

Create a project in TCnotes at your camera's frame rate, then start a recording when the cameras roll. If you have a Tentacle Sync E, jam sync to it so your notes carry the camera's timecode. Without one, start the clock at time of day to match cameras free-running time of day.

Then watch, and type. The timecode locks on your first keystroke, so a note that takes ten seconds to write still lands on the moment you reacted to. On Pro you can hold the mic button and say the note instead.

Pick a color key and stick to it

Colors are the fastest way to tell an agent what kind of note it's reading. This is the key I use, and the one the prompt below expects:

• greenClip-worthy. Use it.
• purpleTeaser hook. Start the note with TEASER OPEN or TEASER CLOSE.
• yellowMaybe. Needs a judgment call.
• redProblem. Cut around it.
• blueB-roll or a camera cue.
• cyanContext for the edit, not a clip.

Write notes the way you'd brief an editor

• Put words said on camera in quotes, like we were broke for 18 months. The agent can then match them against a transcript.
• Say what to do, not only what happened: "skip", "use the second take", "keep under 45s".
• Use a fixed prefix for structure, like TEASER OPEN and TEASER CLOSE, so the agent can't miss it.
• Short is fine. A three-word note at the right frame beats a paragraph at the wrong one.

2. Export your markers

Open the recording and choose Export. Every format is a plain text file with each note at its timecode, so an agent can read whichever one fits the rest of your workflow:

• Premiere Pro XML, DaVinci Resolve marker EDL or Final Cut Pro FCPXML, the same file you'd import into your editing app as markers.
• CSV, one row per note with its timecode, color and text. Open it in a spreadsheet too.

Keep Source timecode selected so the markers match your camera files. If you'll cut on a timeline that starts at 01:00:00:00 on the first frame of the take, pick that option instead. And if your color key matters to the agent, give it the CSV or the Resolve EDL: Premiere Pro XML and FCPXML carry the note's text, not its color.

Here's one note from a 58-minute podcast interview, in two of those exports:

Timecode,Elapsed,Color,Note
14:07:02:02,0:04:51,green,"Origin story, ""we were broke for 18 months"""

<string>14:02:11:00</string>
...
<marker>
  <comment>Origin story, &quot;we were broke for 18 months&quot;</comment>
  <name>Origin story, &quot;we were broke for 18 months&quot;</name>
  <in>6986</in>
  <out>-1</out>
</marker>

Full sample exports, 12 notes each: CSV Premiere Pro XML

3. Hand it to Claude Code

Claude Code is an AI agent that works in a folder on your computer. It can read your markers file, a transcript and your media files, and run tools like ffmpeg to cut clips. Put everything for the episode in one folder:

ep42/
  Ep_42_Founder_Interview_premiere.xml    (or the .csv, .edl or .fcpxml)
  ep42_camA.mov
  ep42_transcript.srt                     (optional, helps it find exact lines)

Open a terminal in that folder, run claude, and paste the prompt. It asks the agent for a plan first, so you approve the selects before anything is cut.

The prompt

It explains every TCnotes export format, so it works with whichever file you hand over. For your own shoots, change the frame rate, the color key if yours differs, and the "What I want" list.

You're my editing assistant. I shot this footage and logged notes live in TCnotes while it happened. The TCnotes markers file in this folder is my brief: every marker is a moment I flagged on set, at its timecode, with my note.

How to read the markers, whichever TCnotes export it is:
- CSV: one row per note. Timecode is the moment, Color is the note's color and Note is my text. Elapsed is time since I started the recording, only a rough cross-check. Initials and Author appear in team exports. Ignore a leading apostrophe (') in a note; it's an escape for spreadsheets.
- Premiere Pro XML (.xml): each <marker> is a note and <comment> is my text. <in> counts frames from the sequence's start timecode (the <string> inside <timecode>), so the marker's timecode is that start plus <in> frames.
- Resolve marker EDL (.edl): each event is a note at its record timecode. |M: is my text and |C: is its color.
- FCPXML (.fcpxml): each <marker> is a note at its start time, in fractional seconds, and value is my text.
Timecodes are HH:MM:SS:FF at 23.976 fps and match the camera's timecode. A ";" before the frames means drop-frame. In team exports, XML and EDL notes start with the author's initials, like [TK].

My color key (colors come through in the CSV and EDL):
  green = clip-worthy, use it
  purple = teaser hook (the note says TEASER OPEN or TEASER CLOSE)
  yellow = maybe, I need to decide
  red = problem, cut around it
  blue = B-roll or a camera cue
  cyan = context for the edit, not a clip

My notes are typed fast. Text in quotes is what was said on camera, close to verbatim.

Timing rules:
- Each timecode is stamped on my first keystroke, so the moment I'm reacting to usually starts 2 to 10 seconds earlier. Back up to the start of the sentence, and end on a breath or a natural beat.
- Before you cut, read each media file's start timecode (ffprobe -v error -show_entries format_tags=timecode:stream_tags=timecode -of default=nw=1 FILE) and convert my timecodes to positions in that file.
- Never use anything inside a red note's moment. When a red note says to use a later take, use the later one.

What I want:
1. A 30 to 60 second teaser that opens on TEASER OPEN, ends on TEASER CLOSE and uses green moments in between.
2. A select list of every green note with in and out timecodes and one line on why it works.
3. The yellow notes, each with your recommendation, for me to decide.

Show me the plan before you cut, render or change anything.

4. Or let the agent drive DaVinci Resolve

MCP (Model Context Protocol) servers are plug-ins that give an AI agent tools for another app. A DaVinci Resolve MCP server lets the agent work in Resolve directly: read timeline markers, find clips and build a new timeline. There are several open-source ones, such as davinci-resolve-mcp. Most need DaVinci Resolve Studio, since that's where Resolve allows external scripting, so check the server's README against your version.

1. In Resolve, open Preferences > System > General and set External scripting using to Local.
2. Install the MCP server and register it with Claude Code as its README describes.
3. In TCnotes, export the recording as a DaVinci Resolve marker EDL. Pick the Timecode setting that matches your timeline: source timecode, or 01:00:00:00 if the timeline starts on the take's first frame.
4. In Resolve, right-click your timeline and choose Timelines > Import > Timeline Markers from EDL. Every note lands as a colored marker you can see too.
5. Start Claude Code in the episode folder and paste the prompt above, then this addition:

You can also control DaVinci Resolve through its MCP tools. The timeline "Ep 42 Founder Interview" already carries my notes as markers, imported from the TCnotes marker EDL: each marker sits at the note's timecode, in the note's color, named with the note's text. Read the markers from the timeline and use the color key above.

Build the teaser as a new timeline called "Ep 42 Teaser". Don't edit, move or delete anything on the original timeline or its markers. When the teaser timeline is built, stop and tell me which clips and timecodes you used.

The agent reads your notes straight off the timeline, at the same frames you see them. Because it builds a separate timeline, your original timeline and markers stay as they were.

What changes in the edit

The agent starts from your judgment instead of guessing at an hour of footage, and you skip the second watch-through to find and mark the good parts. The same notes import as markers in Premiere Pro, Resolve or Final Cut Pro, so a human editor gets the same head start, and on Pro your whole team can log into one shared recording.