How to make a stickman survival POV series with Claude

"Imagine you wake up at 11:58 PM and your phone has one notification: do not open the door." Then a HUD reading DAY 1, a list of rules, a knock, and a choice at the end with two bad options and the words FOLLOW FOR DAY 2. If you have scrolled Shorts or TikTok in late 2026 you have seen this format, often with a stick figure as the hero.

It is one of the best formats for code-made video because almost everything that makes it work is structure, not rendering. The stick figure is simple to draw, the sets can be low-poly, and the tension comes from rules, a clock and point of view. This tutorial covers how creators build it with Claude and turns it into a repeatable series method.

The format in one paragraph

A second-person survival thriller told in about a minute. The viewer is "you". The hook names a time and a situation in the first three seconds. A small HUD tracks the day and a clock that moves forward. Three or four short rules appear, and each one pays off on screen. A threat escalates, mostly shown rather than told. A twist makes one rule impossible to follow. The ending is a choice where both options look bad, which is what fills the comments, and a promise of the next day, which is what earns the follow.

What creators published and claimed

The most complete public method is Finn's stickman prompt, shared as a free "skill" in a single post. It specifies the format, the story rules, the look, a shot library, the tools, the build rules and a set of gotchas, and ends by asking for a beat sheet, a script and six stills before any full render. He says the example took him twenty minutes and nothing on images or video; that is his claim.

Theo (@theoxmotion) studied the pages behind the format, such as itsquarkboi's GRIDLOCK series and drawn.tosurvive's 10th Floor series, which he says show a rule card and a fact card in every part, and published an open rebuild, story-video-studio, with flat stickmen acting inside low-poly rooms under a day-and-clock HUD. He reports that Claude works alone on an episode for about one to two hours from a fresh folder, and adds a warning worth repeating: listen once before you post, because Claude cannot hear the mix. The view counts he quotes for the reference pages are third-party figures he read on one day.

On reach, the claims are large and second-hand. Ernesto Lopez has posted about zombie "DAY 1" survival edits made with Opus 5.5 and their view counts, and about accounts posting similar series. In the replies to one of those posts, Marko Greguric wrote that his own stickman series did millions of views but that "views don't convert that well into downloads", which is the most useful sentence in the thread if you plan to use the format to sell something. Treat every view number here as the poster's claim.

Step 1: write the series bible before episode one

A series lives or dies on consistency. Before you write a single episode, write one short document that every episode will follow. Claude will read it on every run if you keep it in the project as a CLAUDE.md or a bible file.

Series bible sketch

SERIES   "Day N": you survive one night in a place with rules
VIEWER   always "you", present tense, short sentences
HERO     flat stick figure, light body, thick dark outline,
         dot eyes, no mouth, ONE mark: a red cap
HUD      top-left, monospace: DAY 3  ·  02:14 AM (clock advances)
RULES    3-4 per episode, imperative, max 6 words each
TWIST    makes one rule impossible to obey
ENDING   two-choice card, green and red, both bad
         "COMMENT BELOW" + "FOLLOW FOR DAY 4"
LENGTH   60-90 s, 20-30 lines, a new shot every 1.5-3 s
SETTINGS rotate: apartment, subway, hospital, cabin, plane,
         motel, school at night; the threat fits the setting
BANNED   AI frames, glossy 3D characters, emojis, sung music,
         captions longer than 3 words

The one identifying mark on the hero is a small decision with a big payoff. When the story uses a double, a reflection or a callback, viewers need one thing to recognise "you" by.

Step 2: the episode formula

Ask Claude for a beat sheet and the script first, and read both before anything is built. The story rules that do the most work:

• One line equals one visual. If a line needs two shots, it is two lines.
• Open a new question roughly every ten seconds, and only answer it with a bigger one.
• Put the viewer in point of view for the scary parts: through a peephole, a window, a phone screen, a gap under the door.
• Every rule must be paid off on screen. A rule that never matters teaches viewers to ignore rules.
• The ending is a choice where both options look bad. That is what people argue about in the comments.
• Write numbers twice: the caption form ("11:58 PM") and the spoken form ("eleven fifty-eight P M") so text-to-speech reads them correctly.

This last rule comes straight from Finn's prompt and it saves real time. TTS engines read digits inconsistently, and fixing a misread time after the voice is generated means regenerating the line and re-timing the captions.

Step 3: the look, flat figures in lit sets

The distinctive look is a flat 2D stick figure inside a real 3D space. The sets are low-poly but properly lit, and the mood comes almost entirely from light: one warm practical (a lamp, a screen), one cold fill, and one strong accent such as light from under a door, a phone, or a siren through the blinds.

In three.js the trick is to draw each figure with 2D canvas strokes onto its own texture and put that texture on a plane that always faces the camera. With an alpha test the plane casts a real shadow, and a touch of emissive keeps the figure readable in dark scenes. Pose the figure by joint angles and walk it with two-bone inverse kinematics so the planted foot never slides, which is the detail that separates this from cheap puppet animation.

Sketch: a stick figure as a camera-facing sprite with a real shadow

const fig = document.createElement("canvas"); // 512x1024
const g = fig.getContext("2d");
function drawPose(p) {            // p = joint angles at time t
  g.clearRect(0, 0, 512, 1024);
  g.lineCap = "round"; g.lineWidth = 34; g.strokeStyle = "#141414";
  limb(g, p.hip, p.knee, p.foot);  // thick outline pass
  g.lineWidth = 22; g.strokeStyle = "#f2efe8";
  limb(g, p.hip, p.knee, p.foot);  // light body pass
  // ...torso, arms, head, dot eyes, the red cap
}
const tex = new THREE.CanvasTexture(fig);
const mat = new THREE.MeshStandardMaterial({
  map: tex, alphaTest: 0.5, emissive: 0xffffff,
  emissiveMap: tex, emissiveIntensity: 0.08 });
const hero = new THREE.Mesh(new THREE.PlaneGeometry(1, 2), mat);
hero.castShadow = true;

window.seek = (t) => {
  drawPose(poseAt(t)); tex.needsUpdate = true;
  hero.quaternion.copy(camera.quaternion);  // always face camera
  renderer.render(scene, camera);
};

Step 4: a shot library, not a shot list

The format reuses a small set of shot types. Keep them as a library in the bible and pick a handful per episode; using all of them every time makes episodes feel samey.

• The opener: tight on you, pulling out to reveal where you are.
• Point of view on a phone in your hands, the screen drawn in 2D, two stick thumbs.
• A macro on the one detail that matters (the lock, the note, the clock).
• Outside chaos from above: from a balcony or window, vehicles, a running crowd, something collapsing.
• Third-person action in the room: walking, reaching, hesitating, barricading.
• A low angle on a door or vent with light leaking in and shadows moving.
• Knocks, shakes and things falling.
• A fisheye peephole or camera view of the threat stepping closer.
• A close-up on your face for the reaction.
• The choice card and the end card.

Step 5: physics that renders the same every time

Falling debris, a car crash seen from a balcony and a curtain blowing in a broken window all make the world feel real. They also break the golden rule of code-made video, that any frame can be drawn on its own, because physics engines step forward in time.

The fix is to simulate once at load with a fixed timestep, record every body's position and rotation, and then sample those recordings by time inside seek(t). Now frame 1,200 is a lookup, not a simulation, and every render is identical. Cloth (sheets, curtains, flags) can be a simple Verlet particle grid baked the same way.

Bake once, sample by time

const DT = 1 / 240, tracks = [];          // fixed step
for (let i = 0; i <= DURATION / DT; i++) {
  world.step(DT);                          // cannon-es
  tracks.push(bodies.map((b) => [b.position.clone(), b.quaternion.clone()]));
}
const sample = (t) => tracks[Math.min(tracks.length - 1, Math.round(t / DT))];

window.seek = (t) => {
  sample(t).forEach(([p, q], i) => {
    meshes[i].position.copy(p); meshes[i].quaternion.copy(q);
  });
  // ...
};

Our post on satisfying physics simulation videos goes deeper on baking, seeding and making slices and collisions look good.

Step 6: voice and captions that agree

Captions in this format are chunky, one to three words, with key words in an accent colour. They must land on the word as it is spoken, and that is harder than it sounds. Finn's build rules describe the reliable way: if you generate the narration as one long take, do not cut it at the character timestamps the TTS service returns, because they drift and slice words. Instead, transcribe the take with faster-whisper to get real word times, match the words to the script, and cut only in real silences between lines.

For captions, re-transcribe each final line, normalise numbers so "6:42" matches "six forty-two", and snap each caption word to its real start in the audio. Then check that every caption has voice under it within roughly a tenth of a second. Doors and walls are an easy sound design win here: a high-pass, low-pass and short echo on a voice makes it sound like it is coming from the other side.

Step 7: stills, then render, then mix

Ask for six stills of the key shots before the full render. The common faults show up in stills: a figure lit like a 3D object instead of a flat drawing, a night shot that has gone black, dust that reads as stars, a window that is invisible because the glass sits behind a solid frame instead of in a real hole.

Render at 1080 by 1920 with the GPU enabled, then mix: voice on top, a dark drone or tension bed with no vocals about twelve decibels under it, one sound effect per event, a dip just before the big moment, and loudness around -14 LUFS. Make a phone-sized copy under 30 MB for upload.

Pitfalls

• Telling instead of showing the threat. The scariest beats are a shadow under the door and a sound, not a narrator saying it is scary.
• Rules that never pay off. Every rule needs its moment on screen.
• A choice with one obviously right answer. Nobody comments on an easy question.
• Night scenes that compress to black. Always add a cold fill light.
• Narrow lenses indoors. A normal lens sees very little sideways in a small room; go wider and keep the subject near the aim point.
• Dust everywhere. Keep particles inside light beams, or they read as stars.
• Judging motion from a few stills. Check fast moves at full frame rate.
• Copying another channel's episodes, character or catchphrases. Take the structure, write your own stories.

Cost and time

The code route has no media spend: the sets, the figure, the physics and the captions are all drawn, the voice can be local (Kokoro) or ElevenLabs, and sound effects can come from free libraries. The cost is Claude usage and the time it takes to review stills and fix shots. A new series takes the longest on episode one, because that is when you build the figure rig, the HUD, the caption layer and the bible. Episodes after that mostly change the script and the set.

If you plan to monetise on YouTube, read its rules on repetitive and mass-produced content. Rotating settings, writing original stories and keeping a human voice or at least a distinct narration all help a series read as a show rather than a template farm. Our guide to growing a Shorts channel with Claude covers the policy side.

Doing it in about 3 minutes with WhatToUpload Video Studio

Ink stickman is one of the three styles live in Video Studio today, alongside Kinetic type and Diagram explainer, with more being added. You type the episode idea in one sentence and Claude writes the script and storyboard, our renderer draws every frame as code, ElevenLabs voices it and captions and sound are timed for you, in about three minutes.

It is a 2D ink look rather than the lit 3D sets described above, so think of it as the fastest way to test whether a series concept gets watched before you invest in the full build.

A 30 second video is 26 to 30 credits, and plans are $19, $49 and $99 a month.