A Reusable AI Video Pipeline: What BoomEarth Gets Right

Independent verdict

The transferable idea: build a production line, not a giant prompt

A one-off AI video often hides its state inside a chat. The operator asks for a script, regenerates a voice after an edit, estimates subtitle timing, replaces an image, renders twice, and ends with several files named “final.” The result may be usable, but very little of the method survives.

BoomEarth's stronger model is artifact-first. Every expensive or approval-sensitive transition should leave behind something inspectable: a source record, an approved script, an authorized voice reference, a locked WAV and hash, a timing map, a scene plan, a media ledger, a render project, a QC receipt, and a versioned archive. The Agent decides and routes; deterministic programs execute and check.

That division matters. An Agent is good at interpreting a source, choosing a narrative, and mapping an abstract idea to a visual relationship. A program is better at measuring duration, preserving a file hash, rendering the same frame at the same time, or rejecting a missing artifact. Putting both roles into one undifferentiated “make the video” prompt makes failures harder to locate and successful steps easier to repeat accidentally.

The eight contracts in a reusable video system

1. Source contract: identify what the input is, where it came from, which facts it supports, and whether it may be downloaded or transformed.
2. Editorial contract: lock the spoken meaning before spending money on images, ASR, or rendering. Preserve important numbers, qualifications, and cautions.
3. Voice contract: use an authorized reference, record the exact model route, and retain the accepted output rather than silently replacing it.
4. Timing contract: derive word and phrase boundaries from the final audio file. The recording—not a word-count estimate—is the production clock.
5. Visual contract: give every scene one semantic job, define the recurring character or motif, and make movement explain a relationship rather than decorate a caption.
6. Composition contract: freeze media and runtime dependencies locally, then build on one deterministic timeline that can be inspected at exact timestamps.
7. Delivery contract: validate the encoded MP4 separately from the source project or render command.
8. Archive contract: retain the approved inputs, project, media, subtitles, checks, and final file so the next revision starts from known state.

The contracts are more reusable than one mascot or rendering style. A team can replace Chinese narration with another language, swap the hand-drawn character for a diagram-led system, or move from landscape explainers to vertical shorts while preserving the same state boundaries.

What the public repository actually contains

At the reviewed commit, the checkout contained 43 top-level Skill directories, 94 Python files named as test modules, and 40 top-level automation scripts. The folders cover source acquisition, writing and review, voice and captions, illustration routes, motion, delivery, and archives. Those counts establish that the project is substantial; they do not prove that 43 independent modern Skills should be installed or that all tests pass on every machine. Some directories are compatibility entrypoints or retained vendor components.

The public release is also intentionally incomplete in a responsible way. It excludes real environment files, private TTS routing, author voice references, provider responses, private source work, local binaries, and unselected runtime media. That protects privacy, but it means a fresh user must supply and authorize the missing operational pieces.

What our independent preflight established

We cloned the public repository into an isolated workspace and froze the reviewed commit. npm ci installed 139 packages and completed the repository's postinstall copy of its local GSAP runtime. Because uv was not available on the host, we did not claim to have exercised the documented uv installation. Instead, we created a Python 3.11.11 virtual environment and confirmed that the package and declared test dependencies could be installed there.

The HyperFrames doctor found usable Node, FFmpeg, ffprobe, Chrome, disk, and archive tools on the macOS arm64 host. It also found meaningful gaps: the repository's HyperFrames 0.7.106 was behind the tool's reported 0.8.31 release, optional local Kokoro and MusicGen fallbacks were absent, and Docker was unavailable. None of those messages alone proves the documented BoomEarth route cannot work, but they demonstrate why “repository cloned” and “production environment ready” must remain different states.

We also ran every Python test discovered from the clean checkout. The result was 1,639 passed, 133 failed, and 26 skipped in 343.34 seconds. Failure output included tests expecting private or generated configuration and documentation absent from the public release, Windows-oriented path and lock assumptions exercised on macOS, and offline production or delivery contract checks that did not complete successfully. These classes explain some—not necessarily all—of the failures. We preserved the checkout and failure state instead of adding private routing files or patching tests to manufacture a green result.

Download the machine-readable preflight record (JSON). It binds the result to the reviewed commit, dependency-manifest hashes, host environment, exact command and exit code, test counts, duration, retained raw-log digest, public-sample readback, and untested behaviors. The 413,828-byte raw failure log is retained but not published because its traces contain local absolute paths; the JSON records its SHA-256 so the retained file can be checked without exposing those paths.

We then read the public MP4 directly rather than trusting its caption. FFprobe reported a 32.298005-second, 1920 by 1080, 30 fps H.264 High/yuv420p stream with mono AAC-LC audio at 22.05 kHz. Its SHA-256 exactly matched the repository QC record, and FFmpeg decoded the complete file without an error. A visual review of the supplied contact sheet showed four complete hand-drawn scenes revealed in components with one-line subtitles. That supports the project's narrow description: this is an inspectable style and clarity sample, not proof of arbitrary full-body character animation.

A practical adoption test

Do not begin by connecting every provider or attempting a ten-minute video. A useful pilot is one approved paragraph containing two or three ideas and producing roughly 20 to 30 seconds of speech. Keep the pilot separate from client or production work.

1. Freeze the source. Record the repository URL, commit, licenses, and the exact local configuration files that will remain private.
2. Run dependency checks. Confirm the required Python, Node, FFmpeg, ffprobe, and browser versions. Do not automatically upgrade the renderer inside a pinned project.
3. Test the voice route by itself. Generate one short sentence from an authorized reference. Listen for pronunciation, clipping, completeness, and unintended identity drift before connecting it to the workbench.
4. Lock a tiny script. Approve the complete spoken text. If the text changes later, create a new voice version and timing map.
5. Call only necessary providers. A supplied script does not need source-video acquisition. A local timing fixture does not need every optional online service.
6. Create two or three semantic scenes. Each scene should show a cause, action, comparison, path, or result. A mascot standing beside unrelated icons is not an explanation.
7. Render and inspect the exact file. Check duration, streams, black frames, freezes, audio boundaries, subtitle timing, representative frames, and the final frame.
8. Archive the pilot. Retain the accepted audio, timings, scene assets, project, QC output, final MP4, hashes, and an explicit list of what was not tested.

Inspect the checked-out BoomEarth project and its root AGENTS.md first.
Use only this approved script: [PASTE 2-3 SHORT IDEAS].
Create a 20-30 second landscape pilot with my authorized voice route.
Use the current hand-drawn route, no digital avatar, and no source acquisition.

Before any provider call, list the exact input, service, expected output,
data leaving the machine, and budget boundary. Reuse accepted artifacts.
Stop after the reviewable preview unless I separately authorize rendering.
Report completed stages, failed stages, hashes, and untested requirements.

This request is intentionally not a replacement for the repository's Skills or provider permissions. It narrows the job so the operator can discover whether the local route is genuinely connected without wasting calls or manufacturing approval records.

The final voice must control the timeline

The strongest production rule is simple: lock the accepted voice before creating final subtitle and scene timing. Text-to-speech output can vary in pauses, phrasing, pronunciation, and total length even when the text is unchanged. Estimating timestamps from characters or words can produce a video whose total length appears correct while individual phrases drift away from the visuals.

Use ASR or alignment on the exact accepted WAV, correct its transcript against the approved script without inventing new words, and bind each semantic phrase to a visible response. Store the audio hash beside the timings. If a later script edit requires a new WAV, invalidate the old timing map explicitly rather than nudging captions until they appear close.

This audio-first rule overlaps with the existing Grow AI Skills short-video package. BoomEarth adds value around it by connecting earlier source and writing stages and later recovery and archive stages. That is why this review complements the existing Prompt and Skill instead of duplicating them.

An IP becomes useful when it is a contract

A recurring character can create recognition, but a picture alone is not a reusable IP system. Define the character's proportions, facial marks, line weight, palette, allowed poses, forbidden changes, relationship to props, text treatment, and target sizes. Approve an authoritative reference, then make scene assets from that reference rather than asking a model to rediscover the character independently every time.

The character must also perform the explanation. It can lock a script, move a phrase onto a timeline, connect an image to a waveform, or sweep away rejected material. If the character only stands beside a caption, it is branding placed on top of a slideshow. The separate character-consistency workflow covers the identity controls in more detail.

Grow AI Skills should not reuse BoomEarth's square-sponge character, public scene art, private voice, or prompt wording as its own assets. The right editorial move is to explain the abstract system with original diagrams and, if a future behavior test is commissioned, create an independent fixture and visual identity.

Recovery is where the system earns its value

Repeated production rarely fails only at the beginning. A provider may reject one image, a name may be pronounced incorrectly, a caption service may return weak timing, or the last frame may lose part of the end card. Restarting from source acquisition wastes time and can silently change previously approved assets.

Every stage therefore needs an input identity, an output identity, a state, and a reason to invalidate it. A minimal stage receipt should record:

• stage name and version;
• input paths and SHA-256 values;
• tool or provider plus relevant model or dependency version;
• start and completion time;
• result state such as accepted, rejected, incomplete, or superseded;
• output paths and hashes;
• human decision, if one was required;
• the next safe action.

That record turns “do not redo accepted work” from advice into an enforceable workflow. It also makes cost analysis possible: image regeneration, ASR, Agent time, local compute, and human review can be measured by stage instead of collapsed into a promotional per-video number.

Claims that must remain bounded

Version and platform risks

The deployment guide describes Windows as the primary tested environment. A macOS or Linux operator must recheck path syntax, fonts, browser behavior, TTS compatibility, and GPU requirements. IndexTTS has also moved beyond the BoomEarth route's stated IndexTTS2 binding. The official upstream currently documents both IndexTTS2 and 2.5, with different paths and capabilities. Replacing one with the other is a migration, not a transparent upgrade.

The renderer carries the same risk. The checked repository pins HyperFrames 0.7.106 while the local doctor reported 0.8.31 as available. The safe choice for reproducing the public sample is to begin with the pinned lockfile and record the result. Test a deliberate upgrade in a separate branch and compare checks and encoded output before changing the production route.

License and privacy boundary

BoomEarth's license states that original code, tests, documentation, and katerj-* Skill entrypoints are covered by MIT unless a narrower notice applies. Its separate provenance document records retained vendor materials with their own licenses. Several are mapped to CC BY-NC and are explicitly described as not cleared for commercial redistribution.

For Grow AI Skills, the safe pattern is an independent article linking to the authoritative repository. Do not mirror the Skill tree, character media, fonts, examples, or audio. If a small companion asset is ever created, write it independently, preserve attribution, link the required upstream checkout, and keep it useless without the operator reviewing the real source and licenses.

The project's privacy exclusions are a strength. Real credentials, voice references, provider responses, private source material, and local work items do not belong in a public tutorial package. A future behavior test should use an original synthetic script and authorized synthetic or editorial voice, then publish only deliberately selected evidence.

When this system is worth adopting

What a complete Grow AI Skills behavior test would require

To upgrade this page from Source Reviewed and Structure Checked to Behavior Tested, retain a clean-room run that includes all of the following:

• a fresh checkout at a recorded commit and a complete environment inventory;
• an original, approved 20–30 second script with no borrowed character or private source;
• an authorized voice fixture and valid provenance record;
• a successful IndexTTS2 synthesis with listening notes and a locked WAV hash;
• a real final-audio ASR response and corrected timing map;
• original scene images with dimensions, generation records, rights, and visual review;
• a deterministic composition that passes the current project checks;
• a human-reviewed preview and explicit render authorization;
• a formal delivery-check result plus independent FFmpeg readback;
• representative encoded frames, exact final-frame inspection, and a versioned archive;
• actual elapsed time and provider cost separated from setup and human review;
• a failure-and-resume exercise proving that accepted stages are not regenerated.

Final assessment

BoomEarth is valuable because it treats creative production as stateful engineering. Its public materials are unusually candid about missing models, external services, private voice assets, version constraints, sample scope, and the difference between cloning code and connecting a working production route. The public sample is real and independently inspectable.

The project does not yet give an unfamiliar operator proof that every route will work on a clean machine. Our full-suite replay was materially non-green, and its social-growth and average-time claims should not carry the article. The durable lesson is the pipeline: lock meaning, authorize voice, measure real audio, generate semantic scenes, render deterministically, inspect the encoded file, and archive every accepted state. That lesson adds genuine value to Grow AI Skills without duplicating the existing audio-first Prompt or Skill.