lately

I built an app that turns a paper edit into a first cut

Brian Stever

2026 · Swift, SwiftUI, Python, OpenAI · private beta 0.4.1

The short version. Rough Cut is a Mac app that does the first pass of a podcast edit. You give it a Logic or Audition session with each speaker on their own track, and a script with every line labelled by who says it. It transcribes the tape, finds each scripted line, picks a take and hands back a timeline with the clips in script order. It's where eleven years of editing podcasts meets the code I write now. It's in private beta: version 0.4.1, signed and notarized, with builds for Apple Silicon and Intel Macs.

1The job it does

A narrative podcast usually starts with a paper edit: the episode written out as a script, with the host's narration and the interview lines you want, in order, each labelled by speaker. Then someone has to find every one of those lines in hours of raw tape and drag it onto a timeline before the real editing can start. Rough Cut does that part. The app describes itself as being for “the messy middle of the edit”, between a good paper edit and an assembly you can actually shape.

Most of the decisions in it are editing decisions, written down precisely enough for a computer to follow. It's built at Snack Labs, the podcast company I co-founded.

You start from what you already have: a saved Logic project, an Audition session or a folder of WAV or BWF files. Each speaker or source goes on its own track, named the way the script names them. The script can be Markdown, plain text, RTF or a Word document. Speaker labels like HOST: work, and so do bracketed clip markers with timecodes. The parser also knows a paper edit doubles as a to-do list: it skips lines that start with NEED TO or FIND A CLIP, anything marked MIGHT CUT, notes in curly brackets and struck-through text.

An Adobe Audition multitrack session named Demo, with a short host narration clip on track 1 and long guest interview recordings on tracks 2 to 5, each in its own colour.
Figure 1. The demo session from Rough Cut's own setup guide for Audition: host narration on the first track and each interview on its own. The track names are what the script's labels get matched against.

2How it finds each line

First it transcribes every source track with OpenAI's gpt-4o-transcribe, in ten-minute chunks, and gets word-by-word timings from whisper-1. Before it does, it pulls up to 30 capitalised words out of the script and passes them along as likely names and terms, so a guest's name comes back spelled the way the script spells it. Transcripts are cached, so building the same project again doesn't transcribe it again.

Then Silero, a small voice-activity model, splits each track into stretches of speech between pauses. For every line in the script, the engine searches that speaker's transcript for windows that could be it, using anchor phrases, overlapping words and the timecode if the script gave one. It lines each candidate up against the script word by word and scores it.

When the script gives a timecode and nothing matches, it tries harder. It cuts that stretch of tape out and transcribes it again with the scripted line as a hint. If that fails it searches the whole track, and then it stops comparing words and compares meaning, using OpenAI's text-embedding-3-small.

3Choosing between takes

Tape is full of retakes. Narration gets read more than once and guests restart answers, so most lines have more than one candidate. Choosing between them is where the app most needs an editor's judgement, so the scoring is an editor's checklist with weights.

Matching words count most. Starting on the first scripted word counts as much as covering the whole line, and a take that drops its opening words loses another 0.18 on top of that. Clipping the first word is the mistake the scoring works hardest to avoid. Later takes get a small bonus, at most 0.02, on the theory that the later read is usually the keeper.

Counts for a take

  • The words match the script+0.28
  • It covers the whole line+0.18
  • It starts on the first scripted word+0.18
  • Both ends of the line are there+0.14
  • There's a pause to cut on at each end+0.12
  • Words the script quotes are present+0.10
  • It ends on the last scripted word+0.08
  • It sits inside a timecode the script gave+0.04

Counts against it

  • It drops the opening words−0.18
  • It drops the closing words−0.08
  • It drags in extra wordsup to −0.20
Figure 2. How Rough Cut scores a candidate take. Each bar is a weight in the engine's scoring function, drawn to the same scale. A take that drops its first words is marked down twice: once for a weak opening, then again as a penalty.

It also listens for what people say between takes. “Use the last one”, “scratch that”, “one more time” and “that's the one” are all detected in the transcript, and they override the score. If the two best takes are still within 0.08 of each other, it asks gpt-4.1-mini to choose, with the instructions an editor would give: prefer the clean keeper, don't lose the opening words, and when two reads are close the later one is usually better. If that doesn't settle it, it takes the stronger later read.

4What it hands back

The chosen clips go down in script order with 0.15 seconds between them, a little more at a beat, a music cue or a change of segment. For Logic it writes an AAF file, which Logic opens with the clips on their tracks. For Audition it writes a session file that points at the original audio, so nothing gets copied.

A line it can't place with enough confidence, a score under 0.55, doesn't go on the timeline at all. It goes in the issues report, and the timeline keeps a tenth of a second where it would have been. Every build writes that issues report, which also lists each choice between takes, each spoken note it obeyed and any cut that looks suspect, next to a run report of what it found and placed.

For builds that matter there's an optional listen-back check. Rough Cut cuts every placed clip, renders them into one mix, transcribes what it actually hears and compares that with the script. Where a clip starts late or ends early, it tries other candidates and nudged boundaries, and keeps a repair only if it reviews better. It's slower, so it's off by default.

There's also a small Logic plug-in. It's an Audio Unit that passes the audio through untouched; its only jobs are to show Rough Cut's status inside Logic and to open the app. The project has had three names, and the code still carries the first two: the Python engine is logic_arranger and the Swift targets are ScriptCut. Only the app gets to be Rough Cut.

5Getting it onto other people's Macs

The repository starts at the private beta, with a 20,000-line first commit. An earlier Python desktop prototype stayed in there until a cleanup in May. From there it's 46 commits between April 21 and May 8, 2026, and more than a quarter of them are about packaging and signing rather than editing.

Testers don't install Python, Homebrew or ffmpeg. Each release bundles its own Python runtime and static builds of ffmpeg and ffprobe inside the app. It's signed with my Developer ID, notarized by Apple and shipped as separate disk images for Apple Silicon and Intel. The packaging script rejects any build whose signing profiles are missing the app's shared group, which keeps macOS from asking testers whether Rough Cut may access data from other apps.

Each tester brings their own OpenAI API key. It's kept in the macOS Keychain and handed to the engine only as an environment variable, and it must never appear in a job file, a report or a log. The settings screen also points out that a ChatGPT subscription doesn't include API usage.

Intel Macs needed their own fixes. On machines with 8 GB of memory or less, macOS could kill the engine before a build finished. Rough Cut now skips the voice-activity step on those Macs, and if the engine is killed anyway it says why and suggests running the build again, which picks up from the cached transcripts. Version 0.4.1 runs on macOS 14 and later. It builds the first pass and writes down everything it wasn't sure about; the editing after that is still done by a person.