# 6 Anti-Patterns That Consistently Lead to Editing Failures in video-use

> Avoid video editing failures by fixing 6 common anti-patterns like ignoring edit-directory contracts and invalid API responses. Learn to prevent pipeline breaks.

- Repository: [Browser Use/video-use](https://github.com/browser-use/video-use)
- Tags: best-practices
- Published: 2026-07-09

---

**The most common editing failures in the video-use repository stem from ignoring the edit-directory contract, failing to validate ElevenLabs Scribe API responses, and blindly overwriting intermediate artefacts—issues that break the pipeline regardless of the visual style being applied.**

The **browser-use/video-use** repository provides a pipeline that extracts audio, sends it to ElevenLabs Scribe for transcription, and builds edit assets. Several recurring anti-patterns make the editing stage brittle, causing runtime exceptions, wasted API calls, and corrupted artefacts independent of the content being edited or the final visual style applied.

## Ignoring the Edit-Directory Contract

The pipeline assumes a deterministic folder layout where `<video_parent>/edit` contains a `transcripts` sub-folder. However, downstream scripts access this path without guaranteeing its existence.

In [`helpers/transcribe.py`](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py), the `transcribe_one` function creates the directory at lines 102–104:

```python
edit_dir.mkdir(parents=True, exist_ok=True)
transcripts_dir = edit_dir / "transcripts"

```

Yet [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) later expects `edit_dir / "transcripts"` at line 322 without validation. If the directory is missing, the script raises `FileNotFoundError` and aborts the entire run.

**Anti-pattern:**

```python

# Directly reading without ensuring the edit folder exists

transcript_path = Path("edit") / "transcripts" / f"{video.stem}.json"
with open(transcript_path) as f:          # May raise FileNotFoundError

    data = json.load(f)

```

**Correct pattern:**

```python
edit_dir = (args.edit_dir or (video.parent / "edit")).resolve()
transcripts_dir = edit_dir / "transcripts"
transcripts_dir.mkdir(parents=True, exist_ok=True)   # Guarantees existence

transcript_path = transcripts_dir / f"{video.stem}.json"
with open(transcript_path) as f:
    data = json.load(f)

```

## Trusting ElevenLabs Scribe Responses Without Validation

The `call_scribe` function in [`helpers/transcribe.py`](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py) raises an exception only when the HTTP status is not 200 (lines 84–86), but it never validates the JSON payload structure. A partial or malformed response—caused by network glitches or rate-limiting—can lack the `words` key, surfacing as a `KeyError` later when downstream code attempts to read `payload["words"]`.

**Anti-pattern:**

```python
payload = call_scribe(audio, api_key)  # Assumes payload contains "words"

word_count = len(payload["words"])      # May raise KeyError

```

**Correct pattern:**

```python
payload = call_scribe(audio, api_key)
if not isinstance(payload, dict) or "words" not in payload:
    raise RuntimeError("Invalid Scribe response – missing 'words'")
word_count = len(payload["words"])

```

## Re-processing Already-Cached Transcripts

The `transcribe_one` function includes a cache check at lines 106–108, but callers in [`transcribe_batch.py`](https://github.com/browser-use/video-use/blob/main/transcribe_batch.py) often bypass it by re-looping over all videos without checking `out_path.exists()`. This forces unnecessary uploads that consume API quota and increase latency, and if the upload fails, the entire edit step fails despite a valid cached transcript already existing.

**Anti-pattern:**

```python

# Force re-upload even if transcript already exists

out_path = transcribe_one(video, edit_dir, api_key)

```

**Correct pattern:**

```python
out_path = edit_dir / "transcripts" / f"{video.stem}.json"
if out_path.exists():
    print(f"cached: {out_path.name}")   # Avoids unnecessary upload

else:
    out_path = transcribe_one(video, edit_dir, api_key)

```

## Silencing Audio Measurement Failures

In [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py), the loudness measurement step at lines 464–466 falls back to a single-pass when measurement fails, but does not propagate the failure flag. This allows hidden audio issues to persist silently, leading to mismatched loudness in the final edit and causing downstream quality-control scripts to flag the output as broken.

**Anti-pattern:**

```python
target_offset = measure_loudness(src_path)

# If measurement failed, target_offset becomes None → later code crashes

```

**Correct pattern:**

```python
target_offset = measure_loudness(src_path)
if target_offset is None:
    print("⚠️ loudnorm measurement failed — falling back to 1-pass")
    # Continue with a safe default or abort with a clear error

    target_offset = 0.0

```

## Destructively Overwriting Intermediate Artefacts

Helpers like `build_master_srt` and `concat_segments` write directly into `edit_dir` without checking for previous runs. The master subtitle file generation at lines 633–634 in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) overwrites existing files, erasing intermediate cut points, subtitles, or graded clips and making it impossible to recover a previous edit state.

**Anti-pattern:**

```python
sub_path = edit_dir / "master.srt"
sub_path.write_text(srt_content)          # May destroy previous version

```

**Correct pattern:**

```python
sub_path = edit_dir / "master.srt"
if sub_path.exists():
    backup = edit_dir / f"master.srt.bak.{int(time.time())}"
    sub_path.replace(backup)               # Preserve old version

sub_path.write_text(srt_content)

```

## Omitting Filesystem Error Handling

Functions such as `resolve_path()` and `Path.mkdir()` are called without `try/except` blocks throughout the codebase. While `transcribe_one` uses `Path.mkdir(parents=True, exist_ok=True)` at line 102, permission problems or disk-full conditions elsewhere abort the script with raw tracebacks that propagate up as generic "editing failed" messages.

Always guard filesystem operations:

```python
try:
    edit_dir.mkdir(parents=True, exist_ok=True)
except PermissionError as e:
    raise RuntimeError(f"Cannot create edit directory: {e}")

```

## Summary

- **Validate directory existence** before accessing paths in `edit/transcripts` to prevent `FileNotFoundError` exceptions.
- **Inspect ElevenLabs Scribe payloads** for required keys like `words` after checking HTTP status codes in [`helpers/transcribe.py`](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py).
- **Leverage the transcript cache** by checking `out_path.exists()` before calling `transcribe_one` to avoid redundant API calls.
- **Handle measurement failures explicitly** in audio processing rather than silently falling back to single-pass encoding in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py).
- **Backup existing artefacts** before overwriting files in the `edit_dir` to preserve recoverable edit states.
- **Guard filesystem operations** with explicit error handling for permission and disk-space issues.

## Frequently Asked Questions

### Why does video-use require a specific edit directory structure?

The pipeline relies on a **single mutable `edit_dir` tree** that stores all intermediate artefacts in deterministic locations like `edit/transcripts` and `edit/clips_graded`. This design assumes idempotent operations where each step can be re-run safely, but deviations from this layout cause downstream scripts to fail when they cannot locate required files.

### How can I prevent unnecessary API calls to ElevenLabs Scribe?

Check for cached transcripts before invoking `transcribe_one`. The function includes a cache check at lines 106–108 in [`helpers/transcribe.py`](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py), but callers must explicitly verify that `edit_dir / "transcripts" / f"{video.stem}.json"` does not exist before uploading audio. Skipping this check wastes quota and increases latency without improving results.

### What causes "FileNotFoundError" during the rendering phase?

This error typically occurs when [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) or [`helpers/timeline_view.py`](https://github.com/browser-use/video-use/blob/main/helpers/timeline_view.py) attempt to access `edit_dir / "transcripts"` at line 322 without ensuring the directory was created during the transcription phase. Unlike `transcribe_one`, which creates the folder at lines 102–104, render scripts assume the edit directory hierarchy is already present.

### How do I safely overwrite intermediate edit files without losing data?

Before writing to paths like `edit_dir / "master.srt"` (as seen in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) lines 633–634), check if the file exists and create a timestamped backup. This preserves previous cut points and graded clips, allowing you to recover earlier edit states if the current run produces corrupted output.