Coding Stick-Figure Animation: A Workflow Spec That Lowers Short-Video Production Cost

1. Background: Why Video Generation Gets Expensive and Unstable

For individual creators and small teams that need a steady stream of content, short-video production usually includes writing a script, generating visuals, recording voiceover, editing, adding subtitles, and exporting. The video-generation step often has three clear problems.

First, call costs add up. A clip of only a few seconds may take several attempts before the result is usable, especially when character motion, shot continuity, or composition does not match expectations. Creators then regenerate. Even if a single call is inexpensive, repeated trial and error can push monthly spending up quickly.

Second, character consistency is hard to guarantee. Generative approaches usually treat the whole frame as one unit. Changing a line of dialogue or adjusting one action can alter appearance, prop placement, or even camera style. For explainer videos that need continuous storytelling, that uncertainty directly hurts the finished piece.

Third, revisions cost too much. Traditional generation often binds the script, visuals, and motion together. Changing one subtitle or replacing one line of narration still means reprocessing the entire shot. Coded animation can separate text, motion, the timeline, and rendering, so a local change does not force a full rebuild.

Stick-figure animation is a practical place to start because it does not depend on complex materials or photorealistic detail. What matters is timing, composition, shot changes, and information. Once a shared skeleton rule is in place, code can produce a large amount of visually consistent content.

2. Core Idea: Turn Random Creation into Standardized Production

The key is not to ask a coding assistant to write a web page immediately. It is to define a reusable animation spec first, then have the tool generate code that follows that spec.

The workflow can be split into four layers:

1. Content layer: script, narration, subtitles, and shot topics.
2. Motion layer: standing, walking, waving, pointing, jumping, and similar actions.
3. Rendering layer: drawing bones, lines, text, and backgrounds.
4. Export layer: generating frames and assembling them into a video.

These layers should stay loosely coupled. Changing narration should touch only the content layer. Adjusting an arm angle should touch only the motion layer. Changing output size should touch only rendering and export settings. That avoids a small edit that forces the whole pipeline to be redone.

3. A Negative Check First: What Goes Wrong in Unconstrained Animation

Before writing a spec, ask a coding assistant to generate a single-page animation with no extra constraints, just to see the result.

A useful test can ask for:

• a landscape web animation;
• a duration of about fifteen seconds;
• three shots;
• a topic about the difficulties individual creators face when making short videos;
• a simple picture with no unrelated decoration;
• a single-page file that can be opened directly.

This usually produces something that runs quickly, but the problems are obvious.

Character proportions may not be consistent. Head, torso, and limbs have no fixed mathematical relationship, so the same character can change height or arm length between shots.

Motion logic gets messy. Drawing code, time checks, text, and scene changes all live in one file, which makes later edits hard to locate.

Shots lack a shared timeline. An action may finish early in one shot and stall in another, so the overall rhythm breaks.

An unconstrained draft is fine for testing an idea. It is a poor long-term production template.

4. Build a Stick-Figure Animation Workflow Spec

A reusable workflow package should include at least the following.

1. Character skeleton definition

Treat the character as a set of key joints:

• head center;
• neck joint;
• left and right shoulders;
• left and right elbows;
• left and right hands;
• hip center;
• left and right knees;
• left and right feet.

Connect those joints into the head, torso, upper arms, forearms, thighs, and lower legs. Use relative coordinates for every joint instead of hard-coded pixel positions.

Character height can be the base parameter:

character height = H
head radius = 0.08H
torso length = 0.28H
thigh length = 0.22H
lower-leg length = 0.22H

The exact ratios can follow the visual style, but they must stay the same in every shot. Moving the root joint then moves the whole figure without breaking body structure, whether the character is on the left or the right of the frame.

2. Parameterized motion

Do not store an action as a large set of discrete coordinates. Express it with angles, lengths, and time functions.

A wave can be defined as:

shoulder angle = base angle
elbow angle = base angle + sin(time × frequency) × amplitude
hand position = computed from upper-arm and forearm length

Walking can use a sine function to alternate the legs. Motion stays continuous, and speed and amplitude can be adjusted in one place.

To avoid sudden pose changes, add easing. Actions should speed up and slow down at the start and end instead of jumping to the target pose.

3. Shot configuration

Each shot can be described with a structured config:

shot id
start time
end time
background color
character position
character action
subtitle text
transition type

Content and code stay separate. Creators change the config to swap topics, subtitles, or actions without rewriting the drawing logic underneath.

4. A shared canvas and timeline

For a landscape short video, fix the canvas aspect ratio, frame rate, and duration. At sixty frames per second, a fifteen-second animation needs about nine hundred frames.

Compute the timeline from the frame index or from normalized time:

current time = current frame index / frame rate

All motion, subtitles, and shot changes should be driven by that current time. Different modules then share one time unit and do not drift apart.

5. From Web Preview to Local Video Export

A web preview is good for checking motion quickly, but delivery usually needs a video file. Use a two-stage process.

Stage one is interactive preview. Open the animation in a browser and check:

• whether the character deforms;
• whether shot changes feel abrupt;
• whether subtitles stay inside the safe area;
• whether motion matches the narration rhythm;
• whether character proportions stay consistent across shots.

Stage two is offline export. An export script can capture each rendered frame and pass the sequence to a media encoder. Three issues matter here.

Font and asset paths must be stable. Do not rely on temporary network resources, or another machine may miss fonts or fail to load images.

Decide the export size in advance. If the preview and the final video differ in size, text can blur and line weight can change.

Play the exported file all the way through. Successful frame generation does not guarantee a good cut. Check audio-video sync, frame rate, black frames, stutter, and a truncated ending.

6. Why Cost Can Drop Sharply

Local coded animation saves money in three main ways.

First, rendering does not depend on buying video-generation credits one clip at a time. A computer that can run the pipeline can revise and re-export repeatedly.

Second, a local change does not require regenerating everything. A line of dialogue affects subtitles and voiceover. An arm adjustment affects motion parameters. A new background affects the scene config.

Third, the template can be reused. After a stable stick-figure skeleton and shot system exist, later videos mainly replace the script, actions, and subtitles, so the marginal cost falls.

Local production is not free. Computer time, storage, voice tools, human review, and later editing still count. A fair comparison is the total cost of one finished video, not the price of a single tool.

7. A Recommended Acceptance Checklist

Before treating the pipeline as production-ready, check the following.

Structure

• Is there one shared character skeleton definition?
• Are actions generated from parameters?
• Is shot configuration separate from drawing logic?
• Can the export process be run again?

Picture

• Do character proportions stay consistent?
• Do limbs break at the joints?
• Do subtitles stay inside the safe area?
• Do shot changes flicker or skip frames?

Engineering

• Do file paths use relative paths?
• Can external assets load offline?
• Can a failed export be traced to a specific frame?
• Can subtitles be changed without rewriting motion code?

Content

• Does each shot convey one core idea?
• Does motion serve the story rather than decorate it?
• Are subtitles short enough to read?
• Do narration, motion, and transitions share one rhythm?

8. Conclusion

Making stick-figure animation in code changes short-video production from repeatedly sampling a result to generating content by rules. Sampling depends on randomness and is expensive to revise. Rules depend on parameters and templates and are more stable.

What is worth reusing is not one animation file. It is the production method: validate the need with a simple version, record why it failed, then establish skeleton rules, a motion model, shot configuration, and an export process. Once that infrastructure is in place, creators can keep producing stylistically consistent explainer shorts at a lower cost and spend more time on topics, scripts, and content quality.