Academy Video Skills

Three skills that take an Academy lesson from a source text to a storyboard you can approve: the spoken script, the burned captions, the in-scene text, the shot list, the generation prompts, and a page of rendered frames.

The chain

The video pipeline

Each stage owns a narrow contract: what it reads, what it writes, what it is not allowed to touch, and where it stops.

Stage 0 · entry
layerv-academy-video
Routes between the stages and presents each gate. Owns no craft of its own and writes no file.
Stage 1 · script
layerv-video-script
Turns a lesson into the spoken script, the captions, the in-scene text and the episode manifest.
Stage 2 · storyboard
layerv-video-storyboard
Turns the manifest into shots, generation prompts and a page of rendered frames for review.
Stage 3 · generation
generation and assembly
Stills, footage and voiceover, the captions recut against the real audio, then the finished file and its checks.
Skill 01

The entry point

Stage 0 of three
layerv-academy-video

One command for the whole chain. It takes a subject, a lesson URL or a pasted text, works out what already exists on disk, and calls the right stage next. Every rule about what may be written and how a shot is prompted lives in the stage skills, never here.

Reads What the user brought, and the state already on disk under episodes/<slug>/
Writes Nothing itself. Every file is written by the stage it delegates to
Owns The routing decision, and presenting each stage's gate
Why it exists
  • Nobody has to know which of three skills to call, or in what order
  • An episode already half built is resumed, not restarted
  • Every human decision is surfaced in the same place, so no gate is skipped
Skill 02

From a lesson to a script

Stage 1 of three
layerv-video-script

Converts one Academy lesson into an episode: the spoken script, the burned captions with their timings, and the in-scene text, written into a manifest that the storyboard stage and the render pipeline both read. The script is also the voiceover.

Reads The source text, the series glossary, the pipeline config
Writes source.md, episode.yaml, script.md
Owns slug, title, duration, intro, vo, subs, cards, marks
Never touches shots, and anything the production stage writes
Stops at A validated manifest and a script presented for reading. It does not storyboard
The rules it enforces
  • The source is the content
  • The admission gate
  • The answer first
  • One concept per episode
  • One concrete product door
  • The message leads, the number follows
  • One case, followed to the end
  • The captions are the voiceover, word for word
  • The glossary is fixed series wide
Human gate

Two stops: the case line with its beat sheet, and the finished script. Nothing reaches a review page without a written go, per episode.

Skill 03

From a script to a storyboard

Stage 2 of three
layerv-video-storyboard

Turns the episode manifest into its shot list, its generation prompts and the page of rendered frames that gets approved before anything is generated. It reuses footage that already exists before writing a prompt for footage that does not.

Reads The episode manifest, the prompt recipe, the config, the shot library
Writes shots in the manifest, storyboard.md, the rendered storyboard page
Owns shots only: duration, beat, reuse or prompt, reservation, optional replay speed
Never touches The wording of the script, the captions, the cards or the duration. Those belong to stage 1
Stops at A storyboard page presented for review. It does not generate
The rules it enforces
  • Reuse before you generate
  • The arithmetic has to close
  • The teaching zone is reserved, and it is measured
  • The in-scene text is read, never invented
  • The model never draws a glyph
  • Describe geometry, never trade jargon
  • The review artefact is images, not text
Human gate

The storyboard page needs a written go. Nothing is generated, and nothing reaches a review page, before that page has been answered.

Why the rules look like this

Every constraint was bought with a measurement

None of these is a preference. Each one is the result of a generation that came back wrong, measured on the frame, and written into the skill so it is not repeated.

01
Framing is stated absolutely, never relatively
Asked for the same beat a little closer, the model put the character's arm inside the zone reserved for the teaching and cropped the top of his head. Relative framing is not parsed reliably, so the prompt now states the boundary as an absolute: his whole body inside the left half, never crossing the middle.
02
The camera holds still on any shot carrying type
A push in grows the character through the shot, and a growing character shrinks the side that has to stay clear. Measured across a test clip, the trend spends margin for nothing. The acting carries the movement instead of the lens.
03
The reserved zone is measured, not trusted
The earliest clips stood in the space their own prompts had reserved. Occupancy is now measured on the frame, and a clip that fails is refused with a frame strip rather than filed on the strength of the prompt that produced it.
04
Episode length is an output, not a preference
The model generates in fixed blocks and every join costs a full second, because a shorter dissolve reads like an ad break. Only a few finished lengths are reachable, the validator computes them, and it refuses a timeline that does not land on one.
05
Counts are read, never declared
A draft announced one word count and carried another. Every number presented now comes out of the validator instead of out of memory.
06
The caption budget is checked per beat
A total that passes can still hide a single beat nobody can read in time. Each window is checked against its own words, not only against the runtime.
Automated checks

What the validator refuses to let through

The manifest is validated before anything is shown to a human, so a review is spent on judgement rather than on catching arithmetic. Every one of these is a hard refusal, not a warning.

A caption nobody can read in the time it is up
A spoken sentence past the word ceiling
A board past its word ceiling
A screen that holds still too long
A figure that differs between the card, the caption and the voice
A figure drawn on screen that no spoken line says
A label past four words, or carrying punctuation
A second headline in the same episode
Two captions overlapping in time
A timeline whose durations do not add up
A voiceover the runtime cannot carry
A spoken word the source document does not contain
Any drift between the captions and the voiceover, either direction
A title card with nothing to say
A mistyped key in the manifest
A clip standing in the zone its own prompt reserved
Running it

What an operator actually types

The skills call a small set of local tools.

# the whole chain, from a subject or a pasted lesson
/layerv-academy-video

# or one stage at a time
/layerv-video-script
/layerv-video-storyboard

# check the script against the source it came from
python3 tools/check_source_fidelity.py <slug>

# validate the manifest: timings, counts, figures, labels
python3 manifest.py episodes/<slug>/episode.yaml

# what footage already exists and does not need generating
python3 library.py

# render the review page: two frames a shot, captions burned in
python3 build_storyboard.py
What lands per episode
File Carries
source.md The lesson verbatim, with where it came from and the date. Every later claim is checked against it
episode.yaml The source of truth: title, duration, voiceover, captions, in-scene text, shots and prompts
script.md The readable artefact: the gate line, the product door, the voiceover by beat, the captions with their timings, the word counts
storyboard.md One section a shot: its window, its beat, what the character does, the overlays landing on it, and the prompt in full
storyboard page The review artefact: rendered frames with the spoken line and the caption beside each one