Chapter 88. Post Automation: Let Machines Assemble, Let Editors Judge#

Post automation is best suited to assembly work that is repeatable, verifiable and reversible: syncing proxies, building timelines, placing dialogue, drafting subtitles, applying graphic templates, exporting versions and running technical QC. Pacing, performance selection and narrative trade-offs remain the editor's judgment.

88.1 Timeline representation, automatic assembly, and media consistency#

An intermediate timeline representation.

Do not hard-code business logic into one editing application's project file. Generate an intermediate timeline schema first, then let an adapter write it into the target software.

timeline:
  id: ep001_assembly_v03
  frame_rate: 25
  resolution: [1080, 1920]
  tracks:
    video_story: [sh001_take02, sh002_take04]
    video_graphics: [gfx_nameplate, gfx_offer_page]
    dialogue: [line_001_select03, line_002_select01]
    music: [cue_return_v03]
    sfx: [sfx_metal_scrape, sfx_folder_land]
    subtitles: [sub_001, sub_002]
  source_manifest: episode_pack_ep001_v08

The intermediate representation preserves each shot's function, state and provenance. In and out points alone are not enough.

Automatic assembly.

Following the shot list, select the recommended usable range of each approved take, place it on the timeline and preserve handles. Dialogue is placed from the line registry, ambience is laid under each scene, and the cue sheet supplies candidate music entry points. Any missing asset produces a placeholder and an issue — never a silent skip.

Automatic assembly produces a V0 so the editor starts from complete causality instead of an empty timeline and a file hunt. It does not decide the final reaction shot or the length of a pause.

Proxies and media consistency.

High-resolution masters generate proxies keyed to stable asset IDs and timecode. The edit references proxies; after picture lock, relink to masters and verify checksums, frame counts, color and audio channels. Proxies must never pass through a transcode that changes duration.

If a master is replaced with a new version, the system marks the timeline reference stale, and the editor reviews the difference before relinking. Overwriting in place, letting a project change silently, is not allowed.

88.2 Subtitles, graphics, and audio assembly#

The subtitle pipeline.

Dialogue text comes from the locked line registry; speech recognition is used only for time alignment and for spotting divergence. A segmenter produces subtitle candidates by meaning, character count, safe area and rhythm, and proper nouns and numbers are validated against the fact registry. Humans confirm line breaks, tone, legibility and avoidance of picture elements.

Multi-language subtitles derive from the source semantic units, preserving translation, back-translation, duration and cultural adaptation. Changing a source line invalidates every language version and puts them back in the queue.

Graphic templates bound to facts.

Phones, contracts, chats, news and titles use template assets whose content fields bind to fact IDs. The renderer produces transparent graphics plus tracking metadata. A fact update triggers a graphic re-render; it does not regenerate the underlying video.

Templates carry font licensing, minimum type size, color, platform safe areas and extreme text-length tests. Automatic type shrinking has a floor; beyond it, the job returns to a human typesetter.

Audio assembly.

Dialogue, narration, music stems, ambience and Foley are placed per the cue sheet, keeping source files and processing chains. Automatic loudness is only a starting point, and sidechain ducking rules generate automation candidates by narrative priority. The sound supervisor reviews space, performance and the breathing of the music.

When an edit duration changes, the system lists the affected lip sync, Foley, musical bars and subtitles instead of automatically stretching all the sound. Only what can be recomputed locally is handled automatically.

88.3 Export, rollback, and diagnosis#

The delivery matrix.

delivery_profile:
  profile_id: vertical_platform_master
  video: {codec: h265, width: 1080, height: 1920, frame_rate: 25}
  audio: {codec: aac, sample_rate: 48000, channels: stereo}
  variants: [burned_subtitles, clean, textless]
  sidecars: [srt, cue_sheet, checksum_manifest]
  post_export_checks: [duration, black_frames, loudness, subtitle_safe_area]

Export profiles are versioned, and a platform change must not rewrite the history of old projects. Every output is generated from a locked timeline; finishing something by hand on a desktop and uploading it directly is prohibited.

Rollback for automation.

Every automatic assembly and render writes a change set: which clips were created, moved or replaced, and from which input versions. Operations apply to a new version rather than overwriting the editor's current branch, and a failure can be undone completely.

Where an adapter cannot read an editor's manual effects, it must mark an opaque region, so the next automated rebuild does not discard them. Critical manual decisions can be written back into the intermediate representation or locked as protected segments.

Fault tree.

An automatic timeline that opens and cannot be cut: no handles and no shot functions. Subtitles disagreeing with the script: recognition output overwrote locked text. Master relinking to the wrong shot: association by filename rather than asset ID. Fact updates not propagating: graphic content was hard-coded. Automation that editors are afraid to run: no branches, no diffs and no rollback.

88.4 End-to-end acceptance and the value of automation#

SOP, checklist and deliverables.

Define the intermediate timeline representation. Build software adapters. Generate proxies. Auto-assemble V0. Let humans finish the narrative edit. Bind subtitles and graphics to facts. Assemble sound. Lock picture. Relink masters. Export by profile. Re-check technically and store the change set.

• Automation always writes a new version.
• Locked text takes precedence over recognized text.
• Media is associated by asset ID and checksum.
• Manual decisions are protected and traceable.
• Exports are re-imported and verified.

Exercise: generate a 60-second V0 timeline from an episode pack, delivering timeline_schema.json, editor_adapter/, subtitle_pipeline/, graphic_templates/, delivery_profiles/ and automation_diff.json.

One end-to-end assembly acceptance.

Choose a 30-second scene containing dialogue, a reaction, a phone graphic, music and Foley, and run automatic assembly from an empty project. The editor first checks that every approved take appears in its intended function, that handles are preserved, that lines come from the line registry, that graphics bind the correct facts, and that music is present only as a candidate. They then cut the pacing version by hand and save those decisions.

On a second run, the assembler must recognize the existing manual branch, apply updates only to a new branch, and show the difference. Deliberately change one source line, replace one take and extend one shot: the system should invalidate the subtitle, the language versions, the lip sync, the Foley and the music interface respectively — not rebuild the whole project. Finally, generate the clean version, the burned-in version, the subtitle files and the checksum manifest from the locked timeline, then re-import and verify.

Measuring the value of automation.

Do not just count saved clicks. Measure time to first watchable cut, time spent hunting for material, wrong asset references, version rebuild time, release omissions and rework radius. Automation that produces V0 faster while repeatedly overwriting editorial decisions has negative value. Every script needs an exit condition: when the input does not satisfy the contract, stop and file an issue rather than guessing what the operator meant.

The passing condition is that the same locked inputs rebuild the same assembly structure, that manual decisions are never overwritten, that any automated operation can be undone, that export variants match the manifest exactly, and that a different editor can still understand the diff.

A note on sources#

Editing applications and their APIs change constantly, so this chapter stays at the level of an intermediate representation. What transfers is automating assembly rather than judgment, binding graphics to facts instead of literal text, and giving every automated operation a branch and an undo.