How the Self‑Evaluation Loop Verifies Cut Boundary Quality Before User Display

The self‑evaluation loop renders the final video first, then analyzes a ±1.5 second window around each cut boundary using helpers/timeline_view.py to detect visual flashes, audio pops, and stray subtitles before the user ever sees the edit.

The browser-use/video-use toolchain implements a rigorous quality assurance stage that intercepts candidate edits before they reach the user interface. Instead of displaying raw cuts immediately, the system runs a self‑evaluation loop that verifies every cut boundary meets professional broadcast standards. This process ensures that visual continuity, audio cleanliness, and subtitle accuracy are validated programmatically.

Rendering the Candidate Video

The loop begins only after the full edited sequence is materialized. The helpers/render.py module produces the final output—including color grades, transitions, and audio fades—that will eventually be inspected. This is the actual bitstream that users would watch, not proxy media or source files.

All subsequent quality checks operate on this rendered output. By evaluating the final composite rather than preview proxies, the system catches rendering artifacts that might otherwise remain hidden until export.

Generating the Timeline View for Inspection

For each cut point in the edit decision list (EDL), the loop invokes helpers/timeline_view.py against the rendered video. The tool extracts a diagnostic window ±1.5 seconds around the cut timestamp, generating a high‑resolution composite PNG containing:

• A film‑strip of evenly spaced frames (default 10 frames) showing the visual transition
• An audio RMS waveform envelope revealing amplitude discontinuities
• Word labels from the transcript aligned to the timeline
• Shaded silence‑gap bands highlighting pauses longer than 0.4 seconds

According to the repository documentation in SKILL.md (lines 91‑92), this visualization serves as the primary inspection surface for the automated and manual review stages.

The Three‑Point Quality Check

The generated image is analyzed for three specific failure modes that indicate a poor cut boundary:

Visual discontinuity, flash, or jump – The frame sequence is scanned for sudden luminance or spatial changes between the last pre‑cut frame and the first post‑cut frame. Hard cuts that create jarring motion or brightness shifts are flagged for adjustment.

Audio pops and clicks – The waveform envelope is examined for abrupt vertical discontinuities that indicate digital clipping or incomplete frame alignment. The system applies 30 ms audio fades to mask minor inevitable pops, but significant waveform spikes trigger rejection.

Hidden subtitles or captions – Unexpected glyph regions in the composite image reveal stray subtitles that could appear unintentionally. This ensures text overlays appear only at explicit word boundaries, not in the middle of phrases or in silent gaps.

Automated Adjustment and Rejection Logic

When any check fails, the self‑evaluation loop does not display the defective cut. Instead, it automatically adjusts the cut point by snapping to the nearest word boundary or silence gap (≥ 0.4 s) identified in the transcript overlay. If no suitable alternative exists within the tolerance window, the cut is rejected entirely and flagged for manual review.

This feedback mechanism prevents unprofessional “hard cuts” and audio artifacts from reaching the preview stage, guaranteeing that only broadcast‑ready segments are presented to the user.

Manual Verification Workflow

Developers and editors can trigger the same inspection pipeline manually to debug specific timestamps. The workflow requires rendering first, then analyzing the specific cut window:

# 1. Render the edited video with all grades and fades

python helpers/render.py edited_input.mp4 -o rendered_output.mp4

# 2. Generate the timeline view for a cut at 12.34s (window: 10.84s to 13.84s)

python helpers/timeline_view.py rendered_output.mp4 10.84 13.84 -o verify_12.34.png

# 3. Inspect the PNG for flashes, waveform spikes, or stray text

# If defects are found, adjust the EDL and re-render

The timeline_view.py script extracts frames, computes the RMS envelope, and overlays metadata automatically. Inspectors look for smooth frame transitions, continuous waveforms, and clean text regions in the output image.

Summary

• The self‑evaluation loop validates cut boundary quality on the final rendered output from helpers/render.py, not source proxies.
• helpers/timeline_view.py generates a composite PNG spanning ±1.5 seconds around each cut, containing film‑strip frames, audio waveforms, word labels, and silence gaps.
• Three critical defects are detected: visual discontinuities, audio pops/clicks, and hidden subtitles.
• Failed cuts are automatically adjusted to word boundaries or silence gaps, or rejected if no clean alternative exists.
• Manual verification uses the same CLI tools to debug specific timestamps before committing to the final edit.

Frequently Asked Questions

What is the ±1.5 second window used for in the self‑evaluation loop?

The ±1.5 second window defines the temporal scope of the diagnostic image generated by helpers/timeline_view.py. This range provides sufficient context to evaluate the visual and audio transition into and out of the cut while keeping the composite image small enough for rapid automated parsing or human inspection.

How does the system detect audio pops at cut boundaries?

The system analyzes the RMS waveform envelope rendered into the timeline view. Abrupt vertical discontinuities in the waveform indicate digital clipping or frame misalignment. According to the source implementation, the toolchain applies 30 ms audio fades by default to mitigate minor pops, but significant spikes in the envelope trigger a rejection or adjustment of the cut point.

Can I run the cut boundary verification manually without the full automated loop?

Yes. You can manually invoke the same verification steps by first rendering your edit with python helpers/render.py and then running python helpers/timeline_view.py with the specific start and end timestamps (cut time ±1.5 seconds). This generates the diagnostic PNG that you can inspect for visual and audio continuity before the system presents it to the end user.

Where is the self‑evaluation logic documented in the repository?

The high‑level workflow is documented in SKILL.md at lines 91‑92, which describes the quality assurance stage. The concrete implementation resides in helpers/timeline_view.py for image generation and helpers/render.py for final video output, both located in the repository’s helpers directory.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}