Communitygithub.com

character-animation

Designs and animates characters (stickman, mascot, cutout, pixel, line-art, 3D) with consistent, deterministic rigs, poses, acting, and walk mechanics.

What is character-animation?

character-animation is a Claude Code agent skill that designs and animates characters (stickman, mascot, cutout, pixel, line-art, 3D) with consistent, deterministic rigs, poses, acting, and walk mechanics.

Works with~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/achmdfzn/motionforge-atelier/tree/HEAD/.claude/skills/character-animation

Ask in your favorite AI

Open a new chat with this agent skill pre-loaded.

Documentation

CHARACTER ANIMATION

Mission

Design characters and acting that are consistent and readable: stickman, mascot, cutout, pixel character, line-art figure, or 3D.

Pre-production

Define the role, personality, proportions, silhouette, palette, expressions, pivots, and consistency rules. Create character sheets/pose sheets as needed. Designs must be original and must not copy protected characters.

Animation

  1. Start from intention and the acting beat.
  2. Define key poses, timing, spacing, anticipation, action, follow-through, settle.
  3. Use pose-to-pose for complex actions; loop only when the action actually repeats.
  4. Keep volume, proportions, eye direction, and screen direction.
  5. Stickman: prioritize line of action, gesture, timing, silhouette.
  6. Pixel art: pixel-consistent; avoid subpixel blur and changing pixel sizes.
  7. 3D: check the rig, pivots, deformation, foot sliding, clipping.

Remotion rules

Animation is deterministic and frame-driven. State keyframes and durations at 60 FPS. Keep characters inside the safe area and never cover important text.

Mechanics first, drawing second

First solve where the body has to be, then draw around it. Motion born from mechanics reads as alive; motion born from free curves immediately reads as procedural.

Walking and running

  • A planted foot must not slide. The character's forward speed must equal the speed at which the planted foot moves backward relative to the hip: speed = stance_slide / (stance_ratio × cycle_period). Move the character by any other amount and the feet "skate".
  • Never move a figure with a free sine wave (body bobbing on sin(frame)). Hip height is an output, not an input: highest when the legs pass each other, lowest when both feet are planted.
  • The swinging foot lifts low and lands softly; just before lift-off, the foot pivots on the toe.
  • Reference numbers: adults take about 2 steps/second; running children take about 4 steps/second with a forward lean. Hidden legs (under a skirt/robe) are still solved, because the cloth is drawn from the knees and ankles.
  • Story time compressed? Walking speed stays natural. Compress arrival schedules, the sky, and the lights — not the steps.

Things that hang or trail

Sleeves, scarves, bags, hair, lanterns: they all lag behind and then catch up. In Remotion, compute them directly from the frame, never with a per-frame integrator (state += velocity × dt), because the result depends on render order:

  • Lagging follow-through: use Remotion's spring({ frame: frame - delay, fps, config }), with delay a few frames after the parent motion.
  • Damped swing (lantern, bag): angle = A × exp(-k × t) × cos(ω × t) with t = (frame - startFrame) / fps.

Idle life

Characters are never perfectly still: small breaths, blinks, an occasional tail flick. Randomize the intervals, not the shapes, and always with a seed: Remotion's random(\blink-${id}-${n}`), never Math.random()`.

Gestures and reactions

Key a few poses and blend between them with easing. Stop walking first (blend speed to 0 over about 0.4 seconds) before a gesture, then resume. Reactions are the world responding (a bow, a head turn, a cat stretching), not UI elements.

One character, many poses

Build each character once, as a single component/module with its proportions, palette, and line weight locked. Every shot poses that module (joint angles, expression, position); no shot redraws the character from scratch. A character that looks slightly different in each shot is the fastest way to make a video feel amateur. This holds across styles too: if the same character appears as both line-art and cut paper, the proportions and silhouette stay identical and only the medium changes.

Interior detail pass

A silhouette filled with color or texture is not yet a drawing. Before showing any character, check the inside at full size:

  • Face (when the style has faces): mouth line, eyelids, nose, brow, inner ear.
  • Hands and feet: separated fingers/toes where visible, and how the foot meets the ground (contact, weight).
  • Joins: where a limb meets the body or cloth folds at a joint — thinner interior lines than the outline, broken where light hits.
  • Markings: stripes, seams, patches, and patterns follow the surface of the form, not the flat picture plane. Every style shows these in its own way (a pencil accent, a darker marker line, a cut edge), but none may leave them out. Faceless styles (e.g. line-art) carry the same care through hair, hats, posture, and clothing folds.

New means new

When the brief asks for "like this reference, but new", keep the medium, line weight, proportions, and timing feel; invent your own characters, activities, and props. Never reuse characters from the reference.

Output format

  • Character brief: role, personality, proportions (head/torso/limb in the same units across all scenes), silhouette, palette, expressions.
  • Pose sheet: key poses per action with pivots, line of action, and eye direction; reused poses get stable IDs.
  • Rig map: joint pivots, range of motion, and what must not change between scenes.
  • Key-pose timeline (table): pose | frame in/out (half-open) | easing | anticipation/action/follow-through/settle.
  • Expression list: expressions used + at which frame, with no expressions that serve no function.
  • Consistency checklist + asset requirements: pose/sprite/rig files, sources, and status.

QA checklist

  • Proportions, volume, eye direction, and screen direction are consistent between scenes.
  • Every action has anticipation → action → follow-through → settle; no motion appears out of nowhere.
  • Stickman: line of action and silhouette read on a phone screen; line weight is consistent.
  • Pixel art: pixel-consistent, no subpixel blur, no pixel size changes between frames.
  • 3D: no foot sliding, clipping, or unintended rig deformation.
  • Characters do not cover important text and stay in the safe area.
  • Animation is deterministic and frame-driven; keyframes and durations are stated at 60 FPS.
  • Planted feet stay still on the ground during stance (checked on a zoomed frame strip, not in preview).
  • No body bob from a free sine; hip height follows the step phase.
  • Hanging things lag and then settle; no dt integrators or state carried between frames.
  • All randomness is seeded (Remotion's random()).
  • When many characters are needed, one character is approved before the rest (as part of the "look" approval in preflight-review); a set built all at once tends to come out uniform and generic.
  • Each character is one module; shots pose it and never redraw it.
  • The interior detail pass was done at full size (face/hands/feet/joins/markings as the style allows).

Mini example

Stickman typing (frames 0–120): anticipation — hands rise over 12 frames; action — fingers type 1 character every 4 frames; follow-through — hands stop over 6 frames; settle — still pose until the cut. Shoulder and elbow pivots are identical in every scene; if a pose changes proportions, that is a bug, not a style.

Failure modes

  • Character "floats" → check pivots and surface contact at every key pose.
  • Action reads too slow/fast → adjust spacing between key poses first; do not add new poses.
  • Inconsistent expressions → lock the expression list; one expression per beat, not per frame.
  • Feet skate → forward speed does not match the step; compute it from the speed formula, never tune it by eye.
  • Walk looks like a swaying robot → bob from sin(); replace it with hip height derived from foot positions.
  • Motion differs between Studio and the render → state accumulates between frames; replace it with a function of frame.
  • Steps sped up to "fit" the timeline → the walk looks comical; keep the speed, change the arrival schedule.

Second mini example — walking at 2 steps/second at 60 FPS:

const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const t = frame / fps;
const PERIOD = 1.0;          // seconds per foot cycle (2 steps)
const STANCE_RATIO = 0.6;    // share of the cycle the foot is planted
const STANCE_SLIDE = 36;     // px the planted foot travels (relative to the hip) during stance
const speed = STANCE_SLIDE / (STANCE_RATIO * PERIOD); // px/second
const x = speed * t;                       // single source; planted foot stays still in the world
const phase = (t / PERIOD) % 1;            // 0..1, drives foot poses and hip height
const bagSwing = 8 * Math.exp(-1.5 * t) * Math.cos(2 * Math.PI * 1.2 * t);

The numbers above are illustrative; what is mandatory is that x, phase, and the swing are all functions of frame, and that speed is derived from the step.

Idea reference: JDhruv14/line-art-animation (MIT), rewritten for frame-based Remotion.

Individual skills in this repo

This repo contains 4 individual skills — each has its own dedicated page.

Related Skills