# Edit Screen Recordings Faster: A Cut-List Workflow for Tutorials

> Watch the raw take once, write a cut list, then execute it: find silences with ffmpeg, make small text readable, and export with YouTube's recommended settings.

- Canonical page: https://learnhubplay.nl/blog/screen-recording-editing-workflow
- Published: 2026-11-14
- By: LearnHubPlay, an independent software studio in Amsterdam
- Topic: Screen Recording & Tutorials
- Tags: Screen recording, Video production, Templates, YouTube, Checklists

Say you recorded a 14-minute take for a tutorial that should run eight. Editing eats the afternoon, and not because cutting is slow. Every few seconds you stop to decide: is this pause too long, is this wait worth showing, can anyone read that menu on a phone? A pause you shortened in minute two gets a different length in minute nine.

This guide separates deciding from cutting. You watch the raw footage once, at speed, and write a cut list. Then you execute the list without stopping to think. You also get a footage check, an ffmpeg command that lists the silences, a way to calculate how much to zoom, and an export recipe checked against YouTube's upload guidance as it read on 14 November 2026.

Everything works in any editor. The commands need ffmpeg (`brew install ffmpeg` with Homebrew), and we ran each one on a generated test clip with ffmpeg 8.1.1.

## Check the footage before you import it

Screen recorders often save frames only when the picture changes, which gives a variable frame rate (VFR): the gap between frames is not constant. Adobe's community FAQ (2020) says such footage can make Premiere Pro slow or unresponsive, and recommends transcoding to constant frame rate before importing. The page is six years old, so treat it as a reason to test your own file, not a verdict on any editor.

Ask ffprobe, which ships with ffmpeg:

```bash
ffprobe -v error -select_streams v:0 \
  -show_entries stream=r_frame_rate,avg_frame_rate -of csv=p=0 raw.mov
```

For constant frame rate both numbers match, such as `30/1,30/1`. ffmpeg documents `r_frame_rate` as the base rate and `avg_frame_rate` as the average, and warns the base rate "is just a guess", so a gap is a hint, not proof. On a test clip where we dropped frames from still stretches, the output was `30/1,450/71`: a 30 fps base, an average near 6.3 fps.

If the numbers differ, convert a copy to constant frame rate and check that the lengths still match:

```bash
ffmpeg -i raw.mov -fps_mode cfr -r 30 -c:v libx264 -crf 16 -pix_fmt yuv420p -c:a copy raw-cfr.mov
ffprobe -v error -show_entries stream=codec_type,duration -of csv=p=0 raw-cfr.mov
```

The ffmpeg manual says `-fps_mode cfr` duplicates and drops frames to hit exactly the requested rate. If the audio and video durations differ by more than a fraction of a second, discard the copy.

> **Warning:** Every command in this guide writes a new file. Keep the original recording untouched, give each output a new name, and leave out `-y`, which makes ffmpeg overwrite an existing output without asking.

## The review pass: watch once and write a cut list

1. Open the raw file in a player with speed control and set it to 1.5x. Slow down only for fast mouse work.
2. Keep a plain text file beside the player. Do not stop to edit. When something needs action, write one line (start, end, code, note) and keep watching.
3. Use the eight codes below. Add a `CHAPTER` line wherever a new step begins.
4. Watch for private information too. The [pre-flight privacy checklist](https://learnhubplay.nl/blog/screen-recording-privacy-checklist) lists what slips in and why a blur alone can fail.

| Code | What it means |
|---|---|
| `CUT` | Remove a stumble, false start or dead air |
| `TRIM` | Keep the moment, shorten the pause (about 0.5 s) |
| `SKIP` | Cut or speed up a wait; label it if the viewer needs the real duration |
| `ZOOM` | Punch in on small text or a control |
| `LABEL` | Add on-screen text for a value or warning |
| `BLUR` | Hide something private |
| `REDO` | Cannot be fixed in the edit; re-record from the previous step |
| `CHAPTER` | A new section starts |

A cut list for a hypothetical backup tutorial, copyable as a template:

```text
Cut list: backup-setup   raw 14:02   reviewed at 1.5x
start  end    code     note
00:00  00:07  CUT      false start
00:41  00:49  TRIM     hunting for the menu; keep 0.5 s
01:12  01:15  ZOOM     Time Machine list too small; 2x
02:30  02:58  SKIP     first backup runs; cut to the result, label "about 30 s"
03:44  --     REDO     wrong disk showing; re-record from 03:30
05:10  --     CHAPTER  Run the first backup
```

## Find the silences with ffmpeg instead of scrubbing

ffmpeg's `silencedetect` filter logs each stretch where audio stays at or below a noise tolerance for at least a set duration. Its defaults are -60 dB and 2 seconds, so it misses short stumbles and any pause where room noise sits above -60 dB. This version uses -40 dB and 0.8 seconds, and turns the log into start, end and length:

```bash
ffmpeg -nostats -hide_banner -i raw.mov -af "silencedetect=noise=-40dB:d=0.8" -f null - 2>&1 |
  awk 'function t(x){return sprintf("%d:%04.1f", x/60, x%60)}
       /silence_start/{s=$NF}
       /silence_end/{print t(s), t($5), sprintf("%.1f s", $8)}'
```

On a 30-second test clip (a tone with three silent gaps) it printed:

```text
0:06.0 0:09.5 3.5 s
0:16.0 0:17.0 1.0 s
0:24.0 0:30.0 6.0 s
```

`noise` is the level at or below which audio counts as silence, so a more negative value is stricter. If the report flags quiet speech, try -50dB; if it misses audible pauses, raise it toward -35dB.

Treat the output as candidates, not deletions, and merge them into the cut list by what each silence is:

| Silence | Action |
|---|---|
| Before the first word or after the last | `TRIM` to about 1 s, enough handle for a clean cut |
| Restart or thinking pause | `CUT`, or `TRIM` to about 0.5 s |
| Hunting for a menu, file or window | `CUT`, or `SKIP` if the cursor path teaches something |
| Waiting for a load, install or render | `SKIP`, and say the real duration in a label |
| Hold on a finished result | Keep 2 to 5 seconds |

These lengths are starting points to tune, not research results. The last row comes from our [guide to recording software tutorials](https://learnhubplay.nl/blog/record-software-tutorials), which covers the silent hold and its evidence.

Cutting pauses is common practice, not a rule. In Guo, Kim and Rubin's analysis of 6.9 million video-watching sessions on edX, the platform's producers said they edited out "umm", "uhh", filler words and other pauses, because viewers can pause a video themselves. That is a reported practice, not a measured effect, and the videos were online-course material.

## Execute the list in seven moves

1. Duplicate the project, or work from a copy of the file.
2. Work from the bottom of the list to the top, so the timestamps above each edit do not move. Use ripple delete, a delete that closes the gap by pulling later material earlier, for every `CUT` and `TRIM` row.
3. Handle the `SKIP` rows: cut or speed up the wait, then add its label.
4. Apply the `ZOOM`, `LABEL` and `BLUR` rows.
5. Fix the sound: even out levels, then apply the cleanup chain and loudness target from the [budget audio setup guide](https://learnhubplay.nl/blog/budget-microphone-audio-setup).
6. Watch the result once at normal speed without stopping, ideally on a phone speaker. Write down every fix, make them, and stop.
7. Read each chapter start from the finished video, because the cuts moved every raw timestamp. The free [YouTube chapters builder](https://learnhubplay.nl/tools/youtube-chapters-builder) turns a beat sheet into chapter timestamps, and the [chapters, captions and descriptions guide](https://learnhubplay.nl/blog/youtube-chapters-captions-descriptions) has YouTube's rules.

> **Tip:** The bottom-to-top order is the whole trick. Cut the first row first and every later timestamp in your list is wrong, so you are back to scrubbing.

## Make small text readable with a zoom you can calculate

Text shrinks with the frame: a 1920-pixel-wide frame in a player N points wide is scaled by N divided by 1920. Take a hypothetical 13-pixel menu label and three example player widths:

| Player width | Scale | 13 px label shows as | After a 2x zoom |
|---|---|---|---|
| 390 (phone held upright) | 0.20 | 2.6 px | 5.3 px |
| 844 (phone held sideways) | 0.44 | 5.7 px | 11.4 px |
| 1280 (laptop, embedded player) | 0.67 | 8.7 px | 17.3 px |

We know of no universal minimum readable size, so test: export a 20-second sample and watch it on your smallest device at arm's length. If a label the viewer must read fails, add a `ZOOM` row.

A zoom enlarges pixels unless you captured more of them. If the recording is 2,880 pixels wide and you export at 1,920, you can zoom up to 1.5x (2,880 divided by 1,920) before the editor upscales and text goes soft.

Zoom in before the action starts, hold through it, and zoom out afterwards, so the viewer never loses where the control sits in the window.

## Export for YouTube: the settings that matter

YouTube Help's upload encoding page (read 14 November 2026) recommends:

| Setting | YouTube's recommendation |
|---|---|
| Container | MP4, no edit lists, `moov` atom at the front of the file ("Fast Start") |
| Video codec | H.264, progressive, High Profile, 2 consecutive B frames, closed GOP of half the frame rate, CABAC, 4:2:0 |
| Frame rate | The rate you recorded at; do not convert |
| Video bitrate, 1080p SDR | 8 Mbps at 24, 25 or 30 fps; 12 Mbps at 48, 50 or 60 fps |
| Video bitrate, 720p SDR | 5 Mbps; 7.5 Mbps |
| Audio | AAC-LC (the page also lists Opus), stereo, 48 kHz, 384 kbps |
| Colour | BT.709 for SDR |

The page presents the bitrates as recommendations, with no limit required. Most editors' MP4 presets land close, so compare your export dialog with the table before changing anything.

If your editor lacks the controls, ffmpeg can make a matching file from your edited master. This is for 1080p at 30 fps; for 60 fps use `-g 30` and `-b:v 12M`:

```bash
ffmpeg -i master.mov \
  -c:v libx264 -profile:v high -bf 2 -g 15 -flags +cgop -coder 1 \
  -pix_fmt yuv420p -b:v 8M \
  -x264-params colorprim=bt709:transfer=bt709:colormatrix=bt709 \
  -c:a aac -b:a 384k -ar 48000 -ac 2 \
  -movflags +faststart -use_editlist 0 \
  tutorial-1080p30.mp4
```

`-g 15` is half of 30 fps, and `+faststart` moves the index to the front of the file, as the ffmpeg formats manual describes. We checked the output on a generated 1080p30 clip with ffprobe and a short script that lists the file's top-level boxes: High Profile, a keyframe every 15 frames, never more than two B frames in a row, `moov` before `mdat`, no edit list, stereo AAC-LC at 48 kHz, BT.709 tags, and an average video rate of 8.1 Mbps.

> **Note:** The colour flags label the pixels; they do not convert them. In our test with ffmpeg 8.1.1, `-color_primaries` and `-color_trc` never reached the H.264 stream, so the command passes them through `-x264-params`. Encode once from the master; each extra lossy encode discards a little more detail.

## Where to start this week

- [ ] Run the `ffprobe` frame-rate check on your next raw recording.
- [ ] Watch the raw take once at 1.5x, writing a cut list and making no edits.
- [ ] Run the silence command and merge its candidates into the list.
- [ ] Execute the list bottom to top, then watch the result once at normal speed.
- [ ] Compare your export dialog with the YouTube table and save the preset.
- [ ] Note the minutes spent on review, execution and export.

More recording, audio and publishing guides are in the [tutorials topic](https://learnhubplay.nl/topics/tutorials).

## Frequently asked questions

### How long should editing a 10-minute screen recording take?

We found no published benchmark we could verify, and vendor claims of large speed-ups vary too much to quote. Measure instead: log the minutes for review, execution and export on your next three videos. If review is short but execution drags, the footage had problems that were cheaper to prevent while recording.

### Should I remove every silence from a screen recording?

No. Remove pauses that carry nothing, such as stumbles and hunting for a menu, and keep 2 to 5 seconds on a finished result so the viewer can compare it with their own screen. Treat the silence report as a list of candidates and decide each one.

### Why does my screen recording drift out of sync with the audio in my editor?

Variable frame rate is one possible cause. Compare `r_frame_rate` and `avg_frame_rate` with ffprobe, and if they differ, convert a copy to constant frame rate with `-fps_mode cfr`. Adobe's community FAQ ties variable frame rate to slow imports and bad playback in Premiere Pro and recommends this transcoding before import. Other causes exist, so if the converted copy still drifts, check whether the original plays in sync in a media player.

### What export settings does YouTube recommend for a 1080p tutorial?

MP4 with H.264 video (High Profile, progressive, 4:2:0), AAC-LC stereo audio at 48 kHz, the frame rate you recorded at, BT.709 colour, and the `moov` atom at the front of the file. For 1080p SDR, YouTube lists 8 Mbps at 24, 25 or 30 fps and 12 Mbps at 48, 50 or 60 fps, plus 384 kbps stereo audio. These are recommendations, not limits, checked on 14 November 2026.

## Sources and further reading

- [YouTube recommended upload encoding settings](https://support.google.com/youtube/answer/1722171?hl=en) — YouTube Help, read 14 November 2026. The export table.
- [FFmpeg Filters Documentation](https://ffmpeg.org/ffmpeg-filters.html#silencedetect) — FFmpeg project. What `silencedetect` logs, and its defaults.
- [FFmpeg Formats Documentation](https://ffmpeg.org/ffmpeg-formats.html) — FFmpeg project. The `faststart` flag and `use_editlist` option.
- [ffmpeg Documentation](https://ffmpeg.org/ffmpeg.html) — FFmpeg project. `-fps_mode cfr` and the `-y` flag.
- [AVStream Struct Reference](https://ffmpeg.org/doxygen/trunk/structAVStream.html) — FFmpeg project. `r_frame_rate`, `avg_frame_rate` and the "just a guess" warning.
- [FAQ: Issues with screen recorded footage in Premiere Pro](https://community.adobe.com/t5/premiere-pro-discussions/faq-issues-with-screen-recorded-footage-in-premiere-pro/td-p/10874355) — Adobe Community, 2020. Variable frame rate and the advice to transcode first.
- [How Video Production Affects Student Engagement: An Empirical Study of MOOC Videos](https://www.cs.rochester.edu/hci/pubs/pdfs/edX-MOOC-video-production-and-engagement_LAS-2014.pdf) — Guo, Kim and Rubin, ACM Learning at Scale, 2014. The 6.9 million sessions and the edX editing practice.

*[TechCast Studio](https://techcast.learnhubplay.nl/) is the studio's local-first recording workspace for technical creators, currently in Founding Beta on Apple Silicon. It offers trim, silence review, Smart Zoom and cursor effects, and keeps the original source intact. The method above works with any recorder and editor.*
