How to make AI horror Shorts with Claude Code: a step-by-step workflow

An AI horror Short is usually won or lost in its first two seconds. The art is rarely the problem; the story is not built for a feed. A viewer scrolling at speed gives you one frame to show that something is wrong, and every second after that has to earn the next. This guide is the workflow we use to plan and build animated horror episodes with Claude Code: story first, then a written spec, then shots, then checks. It works for Instagram Reels and YouTube Shorts alike, because both are vertical 1080x1920 video.

1. Fix the Shorts format before the idea

Decide the container first, because it shapes the story:

• Length: 45 to 90 seconds. Shorter rarely holds a turn and a reveal; longer loses people on a phone.
• Frame: vertical 1080x1920 at 30 fps. Keep text and the key action in a central band, roughly 25% to 65% from the top, with a margin at the sides (wider on the right): the bottom third, a strip at the top and the right edge sit under the app’s caption and buttons.
• Narration: one narrator with short lines. The narration carries the story and the pictures confirm it.
• Series: plan episodes, not one-offs. A cliffhanger is one of the best growth tools a horror channel has.

2. Write frame 0 and the hook first

Write the opening before anything else and judge it with the sound off. Frame 0 must already show the problem: not a title card, not a slow establishing shot. Three hook shapes work reliably for horror:

• In the middle of it: open on the worst moment, then step back. “The knocking started again at 3:12.”
• The wrong detail: an ordinary room with one thing that should not be there, held long enough to be noticed.
• Stakes on the clock: a deadline the viewer can see, so every second of the episode is a second lost.

The first spoken line should land inside two seconds and ask a question the viewer wants answered. If the hook needs explaining, it is not the hook yet.

3. Build a horror beat sheet that keeps asking questions

A feed viewer stays while they have an open question. So build the episode as a ladder: every beat answers one small question and opens a bigger one. A shape that fits 60 seconds:

1. Hook (0-3 s): the problem, on screen and in the first line.
2. Want (3-10 s): what the main character is trying to do, in one concrete action.
3. Ladder (10-40 s): three or four beats, each a new clue that makes things worse.
4. Turn (around 40 s): the thing they believed is wrong.
5. Scare and reveal (40-55 s): hold the frame a beat longer than feels comfortable just before it.
6. Cliffhanger (last 3-5 s): one new question, not a summary.

Use two different scare mechanisms per episode (for example, something seen too late and something that moves when it should not). The same trick twice reads as a pattern, and patterns stop being scary.

4. Turn the story into a spec Claude Code can follow

Claude Code is very good at turning a precise description into code and very easy to lead astray with a vague one. So the story becomes a written spec file before any scene is built: the story fields, the narration lines with rough times, and the shots. For every shot, write what the viewer sees and what they must understand. That second field is the one that saves episodes: if you cannot say what a shot is for, cut it.

{
  "title": "Room 4",
  "hook": "A hotel guest hears his own voice through the wall",
  "want": "Get out before the voice reaches his door",
  "cliffhanger": "The voice says his name from inside the room",
  "voice": "voice/room4.mp3",
  "lines": [
    { "t": 0.3, "text": "The voice in room 5 was mine." },
    { "t": 2.4, "text": "Same words. Same cough. One second behind me." }
  ],
  "shots": [
    {
      "id": "s01", "start": 0, "end": 2.4, "image": "art/s01.png",
      "sees": "A man pressed to a wallpapered wall, one ear flat against it",
      "understands": "He is listening to something impossible",
      "camera": "slow push-in", "light": "single bedside lamp, warm"
    },
    {
      "id": "s02", "start": 2.4, "end": 5.8, "image": "art/s02.png",
      "sees": "His mouth moving; the wall's shadow moving a beat later",
      "understands": "Something behind the wall copies him with a delay",
      "camera": "drift", "light": "lamp flickers once"
    }
  ]
}

5. Gather the art and the voice

The spec tells you exactly what each shot needs, so make or collect only that. Use your own drawings, commissioned art or generated images you have the rights to, saved as separate layers (background, subject, foreground) so a camera move can give depth. Record the narration yourself or use audio you have a licence for, and save both into the project’s public/ folder under the paths the spec names.

6. Direct Claude Code with the spec, not with adjectives

Give Claude Code the spec file and ask for one step at a time. A prompt that works well:

Read episode/episode.json. Stage shots s01 and s02 in the Remotion project:
- one scene per shot, timed from start/end in the spec
- camera and light exactly as written in each shot
- captions from "lines", inside the band 25% to 65% from the top,
  with side margins (wider on the right)
Do not change the spec. When done, render one still per shot into out/stills/
and list any shot you could not stage as written.

Two habits matter more than the wording. First, when something looks wrong, change the spec and ask Claude to re-stage, rather than patching the scene manually; the spec stays the single source of truth. Second, ask for stills before full renders: a still per shot takes seconds and shows most problems.

7. Make flat art feel deep and frightening

• Camera with a reason: a slow push-in builds dread; a slow drift keeps a held shot alive while the viewer searches the image; a sudden cut is saved for the scare.
• One motivated light: a lamp, a phone screen, a window. Darkness should have shape, not be a black fill.
• A small palette: pick three or four colours for the whole episode and give safety and threat their own temperature, then shift the balance as things get worse.
• Layers: separate foreground, subject and background so a camera move gives parallax. Depth is what makes 2D look expensive.

8. Check the story with a blind read

You know the story, so you cannot judge whether the pictures tell it. Ask Claude Code to pass the still image files to a subagent (or open a fresh session) with no spec or script in its prompt, and ask it to describe, shot by shot, what happens and what it expects next. Compare that with the understands field of each shot. Every shot it misreads gets restaged. Two rounds is usually enough.

9. Render, then run technical QA

Render a short draft first, then the full episode, and check the file before it goes anywhere: 1080x1920, the right duration, an audio stream present, no frozen stretch longer than two seconds and no accidental black frames. Our Remotion + Claude Code guide has the full project code and the exact commands.

10. Post it as a series

• Pay off the last episode’s question in the first two seconds of the next one, then open a new one.
• Keep each episode’s premise new: before you post, compare its hook, setting and reveal with your last few episodes, and change anything that repeats.

Next step: read Claude Code skills for video to package a workflow like this one so Claude follows it every time.