The animated series in five steps

A show is the set of things that outlive any single episode: a look, a cast, a world, and the notes that let the next person pick it up. An episode is what those things do this week. GroundSlate keeps the show in the profile, as collections of kits and avatars, and each episode in a project. A second episode reads the same cast from a new project, so the look never splits.

The film is HTML and every drawing is SVG. A character is SVG parts on a skeleton. A set is SVG planes. A shot is an HTML page that seeks to a time and draws that frame, and GroundSlate captures those pages and assembles the film. A change is an edit to a page or a drawing, then a re-render. Nothing is a pre-rendered clip and nothing is generated as video.

The five steps run in a fixed order: the look before the cast, the cast before the world's scale checks, both before the episode, and the notes before anyone reports done. The Animated Series skill runs all five as one job. When a step needs more depth, The front that can be rigged and The cast that reads at a glance cover step two in full (the drawing, then the puppet), and The sets the camera moves through covers step three.

The components

Every show is made of the same parts, however you build it. The quick build makes all of them in one run and stops at the checkpoints you choose. The full build gives the fronts, the cast and the world a skill each, with more rounds and a review for every front, puppet and set.

1. The show and its look

What you end up with. A bible in the episode project's notes: the premise and the rules of the comedy, the world and its locations, the cast with a silhouette sentence and a voice line for each, the props, the sound. And a style kit: one kit per show, in a collection of kind style_kit, with a palette where every colour has a role, the line rule, the shading, the proportions in heads, and the shared mouth, eye and brow vocabularies with a fallback table. Puppets and style kits explains these objects.

The tools. create_project for the episode, write_project_file for the notes, create_kit_collection with the kind, style_kit_scaffold to start from a kit that already passes, style_kit_doctor to keep it passing, style_kit_sheet for the swatches and the mouth chart.

What you approve. The swatches and the mouth chart, before any character exists. They are shown beside the reference frame they were taken from, so you can judge the match by eye. Beside them is a cast palette table: one row per character, with one saturated hue of their own, their clothing colour against it, and their own darkest value. The kit decides whether the show looks drawn or generated: an even thin line or thick and thin, shading or none, a muted palette or a loud one, small lidded eyes or big white ones. Every front brief copies this kit's style. Changing the kit after the fronts exist means redrawing the fronts and the cast.

How it fails. The agent skips the kit and draws the first character to its own taste, and every later character is drawn to a different one. Or the kit has a look the reference show does not, such as a cel shadow or thick tapered outlines, and everything drawn to it is consistently wrong. Or the kit's twelve swatches become the whole cast's wardrobe: every agent reads the same palette and shades with the same dark, and a sixteen-character show comes back brown and green. The kit is the show's palette; each character gets a row of their own on top of it.

Set up an animated series in GroundSlate called <<SHOW NAME>>, in profile <<PROFILE ID OR NAME>>: a project for episode one with the bible in its notes, and a style kit in a collection of the same name drawn in the spirit of <<A SHOW OR STYLE>>, read off these reference frames <<TWO OR THREE FRAMES, AND WHAT TO TAKE FROM EACH>>. Ask me your questions first, including for more references if these are not enough. Show me the swatches beside the reference and the mouth chart, and stop there.

2. The cast

What you end up with. One approved front per character, then one puppet cut from it. The front is a T-pose SVG in the project's work/fronts/, drawn from a brief that takes its visual style from the kit and describes the character part by part, with a named group for every movable part. The puppet is a kit in a collection of kind puppets: a skeleton, an SVG drawing on every joint per authored view, a mouth chart listing only the visemes it draws, a hand chart it swaps between, costumes on the same skeleton, and slots for props. Each character also gets one avatar that points at the puppet and carries a GroundSlate voice, so a scene and the lipsync tool get body and voice from one id.

The tools. write_project_file for the front brief and the T-pose SVG; preview_frame and preview_html for the front sheet; puppet_doctor for the rules, including the silhouette rule that refuses rectangles and ellipses as anatomy; puppet_sheet for the turnaround, expressions, mouths and costumes; puppet_build for the character file; create_avatar, set_avatar_puppet, create_voice, preview_voice, set_avatar_voice; lipsync to check the chart moves.

What you approve. Each character twice, one character per run of either skill. A run given the whole cast spreads its attention across it, and every front comes back as the same figure with a different caption.

First the front: the brief, then one T-pose SVG on an HTML sheet showing the face at three times size, the whole figure, the flat-black silhouette, and each limb turned 30 degrees on its joint. The checklists are answered with evidence (the stroke widths in the file, the group list, the 64 pixel silhouette), not just ticked. Then the puppet cut from that front, face and body together on the store's own sheet. At the end, a line-up of the whole cast at scale.

The brief is portable. If another model draws a front from it, you already have the vectors: check them and cut them, as long as the kit's stroke policy matches how they were drawn. If you already have vector drawings that are a T-pose front with named groups, those are the front. A generated bitmap sheet is reference only; do not trace it. Review the app's own render, never the agent's own picture of what it meant to import.

The brief is what the character is drawn from: visual style copied from the kit, then palette, head, face with eye size and eye line, hair, neck, torso with its ratios as numbers, shoulders, arms, hands, legs, feet, the flat-black silhouette, personality, and the one contradiction that makes them funny. A name and a sentence produce a schematic figure.

title: The order of the checks
First the silhouette: the T-pose front as a flat black shape, before any colour, and again at 64 pixels. If you cannot name the character from the shape, redesign it; do not shade it. Then the numbers a face needs to carry a scene: the head at least 14 percent of an adult's height and 25 percent of a child's, eyes that read at 200 pixels, three worn items or fewer, and clothing never the skin colour, so a limb crossing the body still stands out against it. The front is a T-pose so the arms can be cut; in scenes the rest pose is arms down, hands empty. Then the structure the doctor cannot see: every round part a cylinder with one axis, so a wheel or a bracelet shows its face only in the view where that axis points at the camera; the same part count in all six views; one 3D head projected per view, so the nose does not grow in profile and the far eye stays inside the skull; collars and bands drawn as rings around the neck or limb. Only then the doctor. A cast that passes the seven structural checks but fails the first two gets rejected on sight.

How it fails. The agent skips the brief and draws from a name, and you get the same figure with a different caption. Or it is given the whole cast in one run and gives each character a tenth of its attention. Or the kit says filled outline and the front has strokes, and the doctor refuses the puppet at the cut over a policy the kit should have declared. Or the visual style is invented instead of copied from the kit, and character three looks like it belongs to a different show. Or a bitmap turnaround sheet is traced.

Passing the doctor is not the goal. No primitives, no strokes and every joint placed is the minimum. The goal is a person looking at the front, with the face at full resolution and the silhouette at 64 pixels. Drawing the cast in parallel, ten characters from ten separate ideas, is another mistake; draw one front, then the next against it. Passing a character on the structural checks alone and calling that approval is the reviewer's mistake. When several characters come from one generator they share its faults, so a bad nose on the father is a bad nose on the whole family, and the fix goes into the generator once.

The full build is The front that can be rigged, then The cast that reads at a glance, each run once per character.

3. The world

What you end up with. One set per location: a kit in a collection of kind sets, with SVG planes at depths that parallax under a pan, a ground line, named marks for every framing the episode needs, interaction points, and a near plane that passes in front of the actors. One SVG kit per prop, in a collection of kind props, with a grip point and the slots it fits. All drawn to the kit.

The brief before the drawing. A set needs a brief just like a character, or it comes back as boxes. Before any plane is drawn, write notes/sets/<set>.md in the same shape as a character brief. Start with the visual style copied from the kit, for this place at this time of day. Then the delivery spec: name, world size, ground, marks, planes. Then the place part by part, one paragraph per object the camera will see, saying what makes it this one and not a generic one. Then the checks.

Then draw it organic: every edge a curve with a little sag, tufts and mop heads and shingles instead of ellipses and rectangles, a shadowed side on every mass. If something still reads as the shape you started from, it is not finished. One early yard built without a brief had a rectangle for the garage, a rectangle on a rectangle for the doors, an ellipse for every bush and a box for the van. The creator rejected it at the first cut, with the cast already animated against it.

The tools. create_kit_collection with the kind, import_kit and save_kit with sheets declared, refresh_kit_preview for the wide, the pan strip and the marks sheet, preview_html on a scale page that puts a puppet on every mark and runs the camera through the shot list.

What you approve. Every set, before any shot is rendered against it. For each set: the wide, the pan and the marks together, plus a probe. The probe places the tallest puppet on every stand mark at the show's scales, sweeps the camera from low to high and through three or four zooms, and checks the head stays clear of every foreground element at each one. The pan is where you judge depth. The marks tell the next agent where the door is. The probe stops a pendant lamp becoming a hat in the first kitchen scene. Every set needs four or more named camera areas, because the cutting rule in step four needs places to cut to. Every prop with lettering is measured against its own width, so the words fit on the paper.

How it fails. A backdrop: one flat painting with no depth and no marks, at a guessed scale. The first pan slides it as one sheet, and the first two-shot puts a character in a doorway shorter than they are. The check that catches this is a scale figure on every mark, in the first round of set notes, before any scene is animated. A set reviewed empty stays at the wrong scale until a puppet stands in it, so never review one empty.

The subtler failure is a near plane at head height: a cable, rail, lamp or canopy in front of the actors that crosses a head in half the camera positions a scene uses. Fix it with depth, not height. Under a pan a foreground plane moves faster than the actors, so raising the element clears one camera and not the next. Moving it behind the actors clears them all.

Draw every object as the camera sees it: a van parked nose out shows two tread faces and a contact shadow, not hubcaps; a bush in a bed stands on the bed's ground line; a chimney is drawn before its roof. Expect the notes to name objects. Fix each one as the camera sees it, and render no shot against the set until it is approved.

The full build is The sets the camera moves through.

4. The episode

What you end up with.

• A beat sheet whose shot durations add up to the episode length.
• A script, and the lines as data: one row per line, with its timing in one place.
• Every line recorded in the character's GroundSlate voice with word timings, and mouths timed from those recordings.
• One seekable HTML page per shot, loading the engine and the SVG rigs from _kit/<collection>/<kit>/ rather than carrying a copy of either.
• A level ledger with a measured peak and RMS for every cue.
• A cut document that assembles those pages with voice, effects, ambience and music placed by frame, each cue at a gain set from its measured level.
• One rendered file per shot, recording the page it came from.
• The film: those shots joined and mixed, committed to the library and reviewed.

title: Cut every ten seconds, and shoot in shots
Nobody watches a background for longer than ten seconds. A 22-minute episode is 270 shots of four to eight seconds, not fifteen scenes, and every cut changes what is behind the character: another camera area of the set, an insert on a prop or a screen, a reaction, an over-the-shoulder. A title sequence cuts every two to three seconds, on the music's bar lines. Each shot is its own page and its own render, so a note on one shot re-renders that shot and nothing else.

The tools. compile_scene turns one scene spec into a rendered scene folder: it finds the cast's puppets, speaks every line in each avatar's own voice and lipsyncs it through that puppet's mouth chart. compile_episode runs it for every scene in a script and cuts the animatic. For steps you drive by hand: synthesize_speech for the takes, lipsync for the mouths, preview_html at shuffled timestamps for every scene, render_html per shot with three running at once, render_concat to join the matching shot files into the picture, cut_doctor and render_cut over that one clip to build the mix, sample_frames and audio_energy across the whole runtime before commit_to_library, and request_review for the cut.

Sound comes from the library or from the app: search_catalog, import_asset and index_audio for what you already have, generate_music and generate_sound_effect for a bed or a cue made to a brief on your Mac. No score is better than the wrong score, so brief the music properly instead of taking the first take.

What you approve. The script as a note, the opener, the first act rendered before the rest is started, and always the cut. For the act, look at a contact sheet of every shot and read three numbers from the mix: the median level during dialogue, the median level in gaps with only the bed, and the loudest second. Dialogue must sit at least twelve decibels above the bed, or the mix is redone.

How it fails. A scene whose frame depends on the previous seek renders wrong, and only the finished film shows it; preview at shuffled timestamps and treat any purity finding as a failure. A cue placed by shot offset instead of film frame lands in the wrong place; cue positions count from the start of the film. A mix checked for ten seconds at the start can be silent from the second shot on; listen across the whole film. No shot should sit still for five seconds.

Lessons from building a full episode:

• A mix built from fixed bus levels because the asset list had no levels, when every generated clip's record already holds its loudness and true peak. Read the record or measure once, and never render a cue without a level.
• A twenty-second opener that was one shot.
• A character pushed to another mark to fit a frame edge. The camera moves, not the character, and anyone not featured is either fully in frame or not drawn.
• A pendant lamp worn as a hat, because the compiler checked the set's own cameras and not the shot's.
• A rig copied into every shot folder, 291 times, until the project refused every note. A rig belongs in the kit store, and a page loads it from _kit/<collection>/<kit>/. write_project_file refuses a copy, and migrate_project_rigs moves any copies an earlier session left behind.
• A join that re-encoded 88 matching hard-cut clips through a merge tree for hours. Concatenate the picture and mix over the single clip.
• A two-word line the voice model overran every time. Synthesise it inside a longer carrier sentence and cut it out by its word timings.
• A 30 fps clip dropped into a 24 fps film with no warning.
• A check that passed 275 shots while measuring nothing, because its lettering check misread the paths. Make every check fail once on purpose before you trust a pass.

The Animated Series covers this step in full, including the show's acting rules.

The camera, and the second frame. Plan the camera first: open wide, cut to faces, vary the framing inside every shot, go tight on a face for a line, punch in when something flies. Inside a page, a cut is a move with no duration, and a snap is a fifth of a second on an exponential ease. Between pages, use hard cuts, and offer the transition catalog only when a cut changes place or time. When a line is about an action, show the action. A title is a designed card in registered fonts, on a plane behind the actors. And a second aspect ratio is a second film: a 16:9 version of a 9:16 short reframes every setup instead of scaling the zoom.

5. The handoff

What you end up with. A PIPELINE.md in the project's notes that says where every layer lives, how an episode is made step by step with the tool for each, the rules that are not negotiable, the problems met along the way, and the order a new agent follows. Every kit id and avatar id, every front brief and front SVG path, the level ledger, the shot render records and the staging sweep table, all on disk. Agents run out of context and hit rate limits mid-render, and the next one picks up from what is written down. A project note that points at it. And proof: a fresh agent, given only the project id, builds one scene of episode two from the notes alone.

The tools. write_project_file, add_project_note, list_project_files and read_project_file for the agent that comes next.

What you approve. Nothing. In this step the agent proves the show works. If the second agent has to ask something the notes should have answered, the notes are fixed before anyone reports done.

How it fails. The notes describe intentions instead of facts: "the look is warm" instead of "every head is a bean, wider at the jaw". Or the ids are missing, so the next agent searches for the cast instead of reading it. Or the notes record what an agent reported rather than what actually changed: a set fix "re-imported" whose store file had a new timestamp and the same bytes, with seven shots still broken. A fix counts when the file's hash has changed, and the note records the hash. A good note is one a stranger can act on without a conversation.

The skill that holds the map

Five steps is the outline. The work inside them is eight jobs (the ask, the bible, the kit, the fronts, the puppets, the world, the episode, the handoff), and step two alone is two skills, each run once per character. The Animated Series is the one to give an agent that needs to understand all of it. It carries the whole pipeline, plus a map of every other skill, recipe and guide on this page and when to hand off to each. It does all five steps in one run, asks its questions once, and stops at the checkpoints you choose.

Use it when the show is small and you want an episode this week. Use the front, cast and sets skills instead when the show itself is the point. A cast of ten that has to look like one show, or a world with a dozen locations the camera moves through, is a week of drawing on its own, and deserves the loop that shows you every front before the next one starts. Expect rejections in that loop. Our sixteen characters took four rounds on the humans and two full redesigns among the aliens, and every round was a picture the creator looked at on the app's render, not a report.